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

With no annotations provided, the description must disclose behavioral traits, but it only repeats the core action. It does not mention side effects, whether the effector attaches to the scene root or selected object, what happens when target is omitted, or any required scene 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 short and front-loaded, with no wasted prose. The Args list compactly maps to the three parameters and adds the necessary detail without redundancy.

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

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

The description covers the basic parameters and their intent, and an output schema exists so return values need no explanation. However, it omits important operational context such as what happens when target is None, whether the effector is applied immediately, and whether a scene must already exist.

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

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

Schema coverage is 0%, so the description carries the burden. It adds meaningful semantics: effector_type lists the accepted values (random, shader, field), and target clarifies its purpose with a concrete example (cloner). Name is self-explanatory but still briefly described.

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 states a specific verb ('Add') and resource ('MoGraph Effector'), making the tool's purpose immediately clear. It does not explicitly contrast with sibling tools like apply_mograph_fields, but the distinct action 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 given on when to use this tool versus alternatives such as create_mograph_cloner or apply_mograph_fields. The description simply states the action without indicating prerequisites, selection criteria, 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 the action (adds an object) but does not disclose whether the operation is destructive, whether it requires an open scene, whether it replaces existing objects, or what the return value contains. 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 core purpose, followed by a concise parameter list. Every sentence earns its place, though the parameter list could be slightly more structured. It is appropriately sized for a simple creation 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?

The tool has an output schema, so return values are covered elsewhere. However, with no annotations and 0% schema description coverage, the description should provide more context about behavior, coordinate systems, and valid primitive types. It is adequate for a simple add operation but leaves gaps that an agent might need to resolve.

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 each parameter with a brief meaning (e.g., 'position: Optional [x, y, z] position'), which adds value beyond the bare schema. However, it does not specify allowed primitive_type values beyond examples, coordinate system conventions, or size interpretation (e.g., radius vs diameter), 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 clearly states the verb ('Add') and resource ('a primitive object to the Cinema 4D scene'), and the parameter list enumerates the primitive types. It is distinguishable from siblings like create_abstract_shape or create_mograph_cloner, though it doesn't explicitly name a sibling to differentiate 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 description implies usage: call this when you need to add a primitive object to the scene. It does not explicitly state when to prefer this over create_abstract_shape or other creation tools, nor does it mention any exclusions or prerequisites. The context is clear enough for a basic agent, but there is no explicit routing guidance.

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

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

The description does not disclose whether the animation replaces an existing animation, whether it mutates the scene permanently, or what happens when camera_name is omitted. With no annotations to supply the safety profile, the description carries the burden alone and only states the basic creation intent.

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, opens with a clear verb phrase, and uses an argument list that scans quickly. Nothing is redundant and every line 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?

It gives enough parameter-level semantics for a basic call, and an output schema presumably covers the return value. It is still thin on behavioral context such as defaults, ownership of the animation, and interaction with other scene objects, so it is only minimally acceptable for an AI agent.

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

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

The schema presumably only lists unnamed parameters, while the description adds practical meaning: animation_type accepts wiggle/orbit/linear, positions are [x,y,z] keyframe values, and frames are frame numbers. This is genuine value beyond the schema, though alignment between positions and frames could be clarified further.

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 phrase 'Create a camera animation' identifies a specific verb and resource, and the parameter list clarifies that it handles wiggle, orbit, linear, and spline animations. It does not explicitly distinguish itself from the sibling set_keyframe, but its scope is reasonably clear.

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 choose this tool over alternatives such as set_keyframe or create_camera, nor about prerequisites like whether a camera must already exist. The description only states what the parameters are, not the intended workflow.

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

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

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It states only that dynamics are 'added' but does not mention whether the operation is destructive, reversible, modifies the object in place, requires an existing object, or how repeated applications behave. This is a significant gap for a mutation-style 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 efficiently brief, with a one-sentence purpose followed by a compact parameter list. Every sentence adds value, and the structure is scannable. It loses one point because the parameter descriptions are sparse and the formatting follows a code docstring style rather than a more agent-friendly natural language structure.

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

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

The tool is simple with only two required parameters and an output schema exists, so the description is functionally sufficient for basic invocation. However, it lacks usage context, alternative routing, and behavioral details, making it incomplete for an agent to decide confidently when this is the right tool.

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

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

Schema description coverage is 0%, and the description compensates by naming each parameter and giving brief meanings. It clarifies object_name as the target object and dynamics_type as 'rigid, soft'. However, it does not specify exact accepted values, constraints, case sensitivity, or default behavior for invalid inputs, so the compensation is only partial.

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 a specific action ('Add dynamics') applied to a specific resource ('the specified object') and distinguishes the two supported dynamics types. However, it does not differentiate this from the sibling tool 'create_soft_body', which may overlap for soft dynamics, so it falls short of a perfect 5.

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

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

No guidance is provided on when to use this tool versus alternatives like create_soft_body, add_effector, or other dynamics-related tools. There are no prerequisites or conditions stated, leaving the agent to infer the correct context 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the high-level action but does not mention side effects, whether existing material assignments are replaced, required preconditions, or error 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 extremely concise, front-loads the action, and the Args section is compact and readable. Every part contributes value without redundancy.

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

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

The description plus input schema is sufficient to know the required arguments and the basic action, and an output schema exists so return values need not be explained. However, it omits important context like whether the material must already exist, how this differs from apply_shader, and what happens if the object or material 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?

Schema description coverage is 0%, but the description provides semantic meaning for both parameters: material_name is the material to apply and object_name is the target object. This compensates well for the empty schema descriptions, though it adds no constraints or additional details.

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

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

The description uses a specific verb and resource ('Apply a material to an object'), making the core action clear. It does not explicitly distinguish itself from the sibling apply_shader, so it lacks differentiation from a closely related tool.

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 like apply_shader or create_material, and no mention of prerequisites such as whether the material or object must already exist. The agent must infer usage from the 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?

Annotations are absent, so the description carries the full burden of behavioral disclosure. 'Create and apply' implies mutation, but it does not mention whether existing fields are replaced, whether the operation can be undone, what prerequisites are needed, or what side effects applying the field may have on 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 and front-loaded with the purpose sentence, followed by a concise parameter list. Each argument line adds some value, though parts of the list largely restate the parameter names already present in the schema.

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

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

The parameter coverage and output schema are enough for basic invocation, and the optional/required split is clear from the schema. However, the description does not explain typical usage contexts, relationship to sibling Mograph tools, or what applying a field does at a scene level, so an agent may still choose or call it incorrectly in ambiguous workflows.

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 so by enumerating allowed field_type values ('spherical, box, cylindrical, linear, radial, noise') and giving concrete parameter cues ('strength, falloff'). This is considerably more than the schema itself provides, though exact parameter shapes and accepted target formats remain 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 description states a specific verb and resource: it creates and applies a MoGraph Field. It is not a tautology and the tool name is clearly expanded, though it does not explicitly differentiate itself from siblings like add_effector or create_mograph_cloner.

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 add_effector or create_mograph_cloner. It only provides a general statement of what it does and does not explain which workflows require it or when it would be inappropriate.

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 the full burden of behavioral disclosure. It states that the tool 'creates and applies' a shader, but it does not reveal side effects such as whether applying a shader overwrites an existing material, what happens if material_name is omitted, or whether the operation is reversible.

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 efficient with no fluff, using a brief Args list to convey the three parameters. It earns slightly less than 5 because it leads with a generic verb phrase rather than a more descriptive single sentence, and the sibling ambiguity is unaddressed.

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 sibling tools create_material and apply_material present, the description does not explain when to use this combined action versus those alternatives. There is no mention of side effects, what happens when optional parameters are omitted, or how the shader type maps to creation behavior. Given the tool creates and mutates scene state accruing both material and object, these gaps are meaningful.

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 gives one-line meanings for all three parameters, plus domain examples for shader_type ('noise, gradient, fresnel, etc'). This adds value but remains shallow – for example, it doesn't clarify what happens when material_name or object_name are omitted, or how shader_type values map to actual 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?

States a clear verb+resource: 'create and apply a specialized shader material.' It distinguishes the tool as performing both creation and application, though the boundary versus sibling tools create_material and apply_material is not explicitly drawn.

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 create_material or apply_material, which are obvious adjacent siblings. The description does not explain prerequisites, when the combined behavior is appropriate, or when the alternatives should be chosen.

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 says only that a shape is created, without explaining side effects, whether the shape is inserted into the current scene, failure behavior, or any prerequisites. This is minimal and leaves an agent to infer the consequences of calling the 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 the purpose, and documents both arguments without fluff. It is efficient for a two-parameter tool, though it is somewhat skeletal and includes no contextual sentence beyond 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?

For a simple creation tool with an output schema, the parameter definitions are sufficient and return values are likely covered by the output schema. However, the description omits broader context such as where the shape appears, how it can be referenced later, and when it should be chosen over sibling creation tools.

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

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

Schema description coverage is 0%, so the description must compensate. It does add real meaning by enumerating shape_type values ('blob, metaball') and clarifying that name is optional, which the schema does not convey beyond generic string/null types.

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 concrete action and resource: 'Create an organic, abstract shape.' The resource type is distinctive enough to separate it from siblings like add_primitive and create_light, though it never names those alternatives explicitly.

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

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

There is no guidance about when to use this tool versus alternatives such as add_primitive or create_mograph_cloner. The only usage signal is the imperative 'Create an organic, abstract shape,' which implies a context but does not state exclusions or trade-offs.

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, and the description only states the basic action. It does not disclose return values, side effects, or whether the camera becomes active/visible 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 concise and front-loaded with the core purpose, followed by compact parameter explanations. No filler or repetition.

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

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

For a mutation-like tool with no annotations and no output schema, the description does not explain the return value, effect on the scene, or constraints of the properties dictionary, so the agent lacks enough context to fully validate the result.

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 Args section adds meaning beyond the raw schema, including an example for properties (focal_length). It explains the purpose of each optional parameter, compensating 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 uses a specific verb and resource ('Create a new camera') with scene context. It is unambiguous, though it does not explicitly distinguish itself from sibling tools like animate_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 purpose is clear, and parameter documentation hints at usage, but there is no explicit guidance on when to choose this tool over alternatives 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 present, so the description carries full responsibility for behavioral transparency. It states 'Add a light to the scene', which implies a mutating operation, but it does not indicate whether a reference or ID is returned, how invalid light_type values are handled, or what other scene state is affected. Without these details, the agent cannot fully predict the tool's 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 very concise: one sentence for purpose and a compact numeric block listing the two parameters. The light_type values are front-loaded and no extensions or unnecessary clauses exist. Every sentence contributes necessary information or adds safety, so it earns a 5.

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

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

The tool is simple with two parameters and likely has an output schema, so return values need not be documented. However, it lacks detail on the effect of choosing a particular light type, possible incompatibilities, or what the described means for the scene. It also does not state whether the 'name' is used for scene graph identification, which could lead to naming conflicts. These gaps are modest but could hinder an agent's ability to make the right 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 adds the valid values for light_type directly in parentheses — 'area, dome, spot' — which is critical semantic information absent from the schema. It also clarifies that 'name' is optional. While it doesn't explain the differences between the light types, the provided enums are valuable and go beyond the raw 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 clearly states 'Add a light to the scene', naming a specific verb and resource. It also lists the specific light types (area, dome, spot), which helps disambiguate from siblings like add_primitive or create_camera. However, it does not explicitly contrast itself with these siblings or describe the purpose of a light in context, which prevents 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 description provides no guidance on when to use this tool versus siblings such as add_primitive or create_camera, and it does not mention any prerequisites or exclusions. An agent has to infer from the tool name that adding a light is the intended use, but there is no explicit when-to-use context. This is a minimal/useless guideline, hence score 2.

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 ('Create') but doesn't disclose side effects, whether the material is added to the current scene, whether it becomes active/selected, or any error conditions. 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 core purpose. The Args list is efficient, though the 'properties' line is vague. No wasted words, but the lack of detail on 'properties' slightly reduces the value of the structure.

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

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

Given the tool has an output schema, return values are covered. However, the description lacks guidance on how 'properties' should be structured, what happens after creation, and how this tool relates to material application or inspection. For a creation tool with no annotations, this 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 compensate. It does add brief meaning for 'name' and 'color' (noting color is optional and values are 0-1), but 'properties' is left as 'Optional additional material properties' with no detail on what keys or formats are expected. The description partially compensates but leaves a key parameter underspecified.

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: 'Create a new material in Cinema 4D.' This clearly distinguishes it from siblings like apply_material or inspect_redshift_materials, though it doesn't explicitly name those alternatives. The purpose is clear and actionable.

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 (creating a material in Cinema 4D) but provides no explicit guidance on when to use this tool versus alternatives like apply_material or inspect_redshift_materials. It doesn't state exclusions or prerequisites, so an agent must infer the appropriate context 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?

No annotations are provided, so the description carries the full burden. It discloses that a cloner is created, but does not mention whether it replaces an existing cloner, whether it requires a selected object, what the default name is, or any side effects. For a creation tool, this is a notable gap.

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

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

The description is short and front-loaded with the main purpose. The Args section is compact. It earns its place, though it could be slightly more informative without becoming bloated.

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

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

Given that there is no output schema and no annotations, the description is incomplete. It does not mention what the tool returns (e.g., the created cloner's path or ID), nor any prerequisites or side effects. An agent would need more context to invoke it 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?

Schema description coverage is 0%, so the description must compensate. It does explain cloner_type (grid, radial, linear) and name (optional), but it does not clarify the exact accepted values for cloner_type (e.g., case sensitivity, exact strings) or how the name is used. The description adds some meaning but leaves 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 a specific verb ('Create') and resource ('MoGraph Cloner object'), and names the cloner types (grid, radial, linear). It is clear what the tool does, though it does not explicitly distinguish it from sibling tools like add_primitive or add_effector.

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 such as add_primitive or add_effector. The description implies it is for creating cloners, but there is no explicit context or exclusion.

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

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

The description reveals that the tool mutates an object by adding dynamics, but it does not disclose whether the operation is destructive, whether it overrides existing dynamics, what object types are supported, or what the result looks like. With no annotations available, the description carries the full transparency burden and only partially meets it.

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

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

The description is short and front-loaded, with the operation and target in the first sentence)Skip. There is no filler or redundant restatement, though the sparse Args section is not a structural problem.

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 only one sentence of context, the definition leaves important operational questions unanswered: whether the operation is reversible, whether it affects existing dynamics, and what error cases exist. It is minimally sufficient for a simple call but not genuinely 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 Args line clarifies that object_name is the object to convert, which adds function to the bare schema property title 'Object Name'. However, it gives no guidance on naming conventions, object references, or what happens if the object does not exist.

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 soft body dynamics') and names the target object, so an agent can tell what the tool does. It does not, however, distinguish itself from closely related sibling tools such as apply_dynamics or modify_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?

No guidance is provided about when to use this tool versus alternatives like apply_dynamics or create_soft_body. The agent must infer placement in a workflow 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?

With no annotations, the description carries the burden of behavioral disclosure. 'Using an isolated temporary document' hints that the operation is non-persistent and isolated from the active scene, which is useful. However, it does not explain side effects, error behavior, or requirements, so the disclosure is incomplete.

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

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

The description is a single front-loaded sentence with no filler. It is concise, though its brevity sacrifices explanatory 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?

An output schema exists, so return values may be covered elsewhere, but the description lacks usage guidance, parameter semantics, and sufficient behavioral detail. For a two-parameter tool with no annotations, an agent needs more context to invoke 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% and the description provides no meaning for asset_id or asset_version beyond their names. The optional asset_version parameter is especially unexplained; an agent would not know what versions are valid or how the parameter affects the describe 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 uses a specific verb ('Describe') and resource ('Capsule asset') and adds a distinguishing mechanism ('using an isolated temporary document'). It is clear enough about the tool's action, though it does not explicitly differentiate it from sibling tools like inspect_capsule_graph or describe_scene_node_asset.

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 search_capsule_assets or inspect_capsule_instances. The description only states the action, leaving the agent to infer appropriate use cases.

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 behavioral disclosure burden. The phrase 'isolated temporary document' usefully suggests a non-destructive, quarantined operation, but it does not clarify what happens to the document, whether the main scene is touched, or what side effects occur beyond the description.

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

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

The description is a single, front-loaded sentence with no wasted words. It is concise, though slightly under-specified in content; the structure itself is clean and readable.

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

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

For a one-parameter tool with an output schema, the description provides a minimally viable level of context: action, resource, and isolation. However, it omits where asset IDs come from, how this tool relates to asset search siblings, and any prerequisites for calling it.

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

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

The only parameter, asset_id, has no schema description (0% coverage), and the tool description does not explain its meaning, format, or how to obtain it. The property name implies it is an ID, but the description adds no value beyond that.

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

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

The description clearly states a specific action ('Describe') and resource ('Scene Nodes asset'), and the added 'isolated temporary document' gives useful context. It is somewhat distinguishable from siblings like search_scene_node_assets, though it does not explicitly contrast with inspect_scene_nodes_graph or describe_capsule_asset.

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 for when to use this tool instead of alternatives such as search_scene_node_assets or inspect_scene_nodes_graph. There are no conditions, exclusions, or recommended sibling tools 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. 'Ordered partial-success operations' is a meaningful behavioral disclosure: it tells the agent that operations are applied in order and may partially succeed. However, it doesn't disclose what happens on partial failure (rollback? partial commit?), whether the operation is destructive, or what the output schema contains.

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

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

The description is a single compact sentence that front-loads the core action and resource. It earns its place, though it could add a bit more guidance without becoming bloated.

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 7-parameter tool with nested objects, 0% schema coverage, and no annotations, the description is too thin. The agent has no idea what 'operations' should look like, what write_mode values exist, what graph_target requires, or what the output schema returns. The 'ordered partial-success' hint is useful but insufficient.

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

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

Schema description coverage is 0%, so the description must compensate, but it only mentions 'operations' implicitly and 'graph_target' via 'one exact Capsule instance graph'. The other 5 parameters (layout, debug_path, write_mode, focus_editor, layout_after_batch) are completely unexplained in both the description and the schema, leaving the agent to guess their 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 verb ('Edit') and resource ('one exact Capsule instance graph'), and adds a distinctive qualifier ('ordered partial-success operations') that hints at its transactional semantics. It is distinguishable from siblings like inspect_capsule_graph or layout_capsule_graph, 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 this is the tool to use when editing a Capsule instance graph, and the 'ordered partial-success operations' phrase suggests a batch-edit context. However, it provides no explicit when-to-use vs alternatives, no exclusions, and no guidance on how it differs from edit_scene_nodes_graph or other edit 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 must carry the full burden. It discloses 'per-operation rollback' but omits details like failure semantics, whether the batch is atomic, permission requirements, or response format. This is minimal.

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

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

The description is a single sentence, concise and not bloated. However, it is so brief that it lacks necessary context, and there is no structure or breakdown to aid comprehension. It's concise but under-specified.

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 four parameters including a required array of complex operations, and with no annotations or output schema description, the description is severely incomplete. It doesn't explain the operations format, the purpose of layout/debug_path, or what the response contains. An agent would have little idea how to 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% and the description mentions no parameter details. The only hint is 'operations' in the phrase 'Scene Nodes graph operations', but it doesn't explain the operations array structure, layout, debug_path, or layout_after_batch. The description adds almost no meaning beyond the schema.

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

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

The description states a clear verb ('Apply') and resource ('Scene Nodes graph operations'), and mentions 'per-operation rollback' which distinguishes it from inspection/layout tools. However, it doesn't enumerate what operations are supported or differentiate from edit_capsule_graph explicitly.

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

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

No guidance on when to use this tool versus alternatives. It doesn't mention that it's for scene nodes as opposed to capsule graphs, nor does it specify prerequisites or typical use cases.

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 given, so the description carries the behavioral disclosure burden. It discloses security restrictions, print-based output capture, and advises sequential frame stepping for fidelity—all behaviors beyond the raw schema. It could additionally state scene mutation/side effects, but it already makes the environment and restrictions clear.

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

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

The description is front-loaded with the tool's purpose and then supplies operationLogically organized bullet-point notes. It is somewhat longer than a one-liner, but every sentence earns its place by giving necessary execution, security, and frame-iteration guidance.

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

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

For an open-ended Python execution tool, the description is fairly rich: publication does not explicitly mention `doc` is in scope, but examples use it. Given output schema is declared and this is a powerful script executor, the existing notes cover the main hazards; minor omission of the doc variable remains, but the overall context is enough.

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 provides only the name 'script' with type string and zero description coverage. The description fully compensates by stating the script is Python code to execute can import c4d and c4d.modules.mograph, and some print() returns results? Actually the description explains all meaning needed for the sole parameter.

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

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

The description states a specific verb-resource pair: 'Execute a Python script in Cinema 4D's Python environment.' It also distinguishes this tool from siblings by highlighting full c4d API access and calling it the most reliable tool for non-trivial operations, so an agent can clearly tell when it fits.

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

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

It gives clear context for when to use the tool, such as for animated/MoGraph data needing doc.ExecutePasses(), sequential frame iteration, and heavy operations split into smaller scripts. It does not explicitly list alternative tools for exclusion, but the context is specific enough to guide correct invocation.

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 entire disclosure burden introduce. It states a user-facing request ('request that Cinema 4D show its exact graph') but doesn't disclose whether this modifies state, changes selection, opens a panel, or has side effects. It also doesn't mention important constraints like whether graph_target needs to be a specific node type.

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

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

The description is a single sentence, no fluff, but the phrasing 'Select a Capsule owner and request that Cinema 4D show its exact graph' is awkwardly indirect ('request that' instead of 'shows/focuses'). It is concise but not optimally structured; however, it doesn't waste words.

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

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

Given no annotations, one undocumented free-form parameter, and siblings performing similar graph operations, the description does not provide enough context. It fails to explain what a Capsule owner is, what graph is shown, how output is returned, or any prerequisites. Overall incomplete for an agent to use 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?

Schema has one free-form object 'graph_target' with 0% schema description coveragecars. The description loosely implies graph_target identifies a 'Capsule owner', but gives no shape, keys, or example, leaving the agent to guess what fields to provide. This is a significant gap for a single-parameter tool.

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

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

The description identifies a verb ('focus' / 'request ... show') and a resource ('Capsule owner' graph), but it's vague about what 'show its exact graph' actually accomplishes. It doesn't clearly distinguish from sibling tools like inspect_capsule_graph or layout_capsule_graph, leaving ambiguity about the operation's precise effect.

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 vs. alternatives. The clustering of capsule graph tools (inspect/edit/layout/focus) makes this a significant gap. The description implies intent but offers no explicit when/when-not guidance.

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

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

No annotations are provided, so the description must carry the behavioral burden. 'Get information' implies a read-only, non-destructive operation, but the description does not clarify what scene state is included, whether a scene must be open, or any failure behavior. This is minimal but not misleading.

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

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

The description is a single concise sentence with the action and resource front-loaded. Every word contributes, and there is no redundancy or 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?

Given the zero-parameter interface and the presence of an output schema, the description does not need to enumerate return values. It is slightly vague about the exact scope of 'information' and does not differentiate from sibling inspection tools, but for a simple getter it is largely sufficient.

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

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

The tool has zero parameters and an empty input schema, so there is no parameter information for the description to add. Per the rubric, zero parameters receives a baseline score of 4.

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 ('Get') and resource ('information about the current Cinema 4D scene'), so the core purpose is clear. It does not explicitly distinguish itself from sibling inspection tools such as list_objects or inspect_scene_nodes_graph, which prevents a top score.

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 call this tool versus any sibling tool. There are no conditions, exclusions, or alternative routing, so an agent must infer the appropriate use from the generic wording.

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 responsibility for disclosing behavior. It mentions grouping under a null object but does not explain side effects: whether object transforms are preserved, what happens when group_name is omitted, whether objects are reparented, or whether the operation is destructive or reversible.

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

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

The description is short and front-loaded, with the action stated first and parameters listed compactly. No filler or redundant material is present, though it is terse enough that some behavioral details are omitted.

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?

An output schema exists, so return-value documentation is not required, and the parameter list is simple. However, with no annotations and no usage or behavioral guidance, the description is incomplete for a mutating tool: an agent cannot infer failure modes, side effects, or whether it is safe to call in a given scene state.

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 adds brief plain-language meanings for both parameters: object_names are the objects to group and group_name is optional. This compensates partially, though it doesn't explain naming conventions, default behavior for group_name, or whether names refer to scene node names specifically.

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 ('Group') and resource ('objects under a null object'), clearly conveying the tool's core function. It is not a tautology and is distinguishable from siblings like list_objects or modify_object, though it doesn't explicitly contrast itself with any 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?

There is no guidance about when to use this tool versus alternatives like modify_object or create_mograph_cloner. The description states what the tool does but gives no context on prerequisites, scene hierarchy conventions, or when grouping is the appropriate 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. 'Inspect' implies a read-only operation, but nothing is said about limits, side effects, scope of the inspection, or how the graph_target is resolved.

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

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

The description is a single, front-loaded, grammatically clear sentence with no wasted words. It is appropriately concise for what it says, though it is thin relative to the tool's complexity.

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 complex tool with 11 parameters, a nested graph_target object, and no annotation coverage. A one-sentence description is not enough for an agent to understand the meanings of the various limits and toggles, or to know how to construct a valid graph_target.

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 adds meaning only for graph_target, which is already visible in the schema. With 11 parameters and 0% schema description coverage, the other parameters (limit, max_bytes, node_path, include_ports, include_connections, etc.) remain semantically unexplained.

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

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

The description uses a specific verb ('Inspect') and resource ('Capsule instance graph'), and names the key identifier ('graph_target'). It is clear enough to distinguish from scene-graph tools, though it does not explicitly differentiate itself from sibling inspection tools like inspect_capsule_instances.

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 inspect_capsule_instances, focus_capsule_graph, or edit_capsule_graph. The intended use is only weakly implied by the word 'Inspect'.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Discover' vaguely suggests a read-only/no-side-effect operation, but there is no explicit statement about non-mutation, result size limits, or performance implications. The limit and max_bytes parameters hint at potentially large outputs, but the description is silent on this.

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

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

The description is a single front-loaded sentence with no wasted words. However, it is under-specified for a five-parameter discovery tool; brevity alone does not make it appropriately sized.

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?

An output schema exists, so return structure is covered, and all parameters are optional. But the description still lacks essential context: what exactly constitutes an instance graph, how parameters constrain the discovery, and what makes this tool distinct from closely named siblings. Adequate is not achieved.

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 mentions none of the five parameters. While titles like 'Limit' and 'Max Bytes' are somewhat self-explanatory, 'node_space' and 'owner_guid' are ambiguous, and the description does nothing to clarify their purpose. It fails to compensate for the lack of schema descriptions.

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

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

The description states a specific action ('Discover'), specific resources ('object, tag, and Capsule instance graphs'), and a clear context ('active document'). It reads distinctly from siblings like list_objects (objects only) and inspect_capsule_graph (inspect, not discover instances), 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?

There is no guidance on when to use this tool versus the many sibling tools such as inspect_scene_nodes_graph, inspect_capsule_graph, or list_objects. No when-to-use, when-not-to-use, 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 provided, the description carries the full behavioral burden and does so well: it discloses read-only semantics, best-effort fallbacks, partial functionality without the Redshift runtime, and conditional data availability for node-graph inspection. This is exactly the kind of behavioral transparency that helps an agent predict outcomes.

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 key purpose and fallback behavior, and then lists parameters in a scannable block. Every sentence carries useful information 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 tool with six optional parameters and an output schema, the description covers the operation's limitations, read-only nature, and each parameter's intent. Nothing critical is missing for an agent deciding when and how to call 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%, but the Args block explains every parameter in plain terms: filter, include assignments, preview colors, descriptions, container values, and graph inspection. This adds real meaning beyond the bare schema titles and tells the agent what each flag controls.

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 names the exact resource and action: 'Inspect Redshift materials', and the follow-up clarifies it is a read-only introspection tool. This cleanly separates it from sibling creation/application tools like create_material and apply_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 states it is read-only, designed to work even when the Redshift Python runtime is unavailable, and that graph inspection only happens when Cinema 4D exposes that data. It gives clear context for when to use it, though it does not explicitly name alternative tools or exclusion cases.

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 'Inspect' and does not explain read-only guarantees, output shape, truncation behavior, or side effects. It is not misleading, but it is largely silent for a complex inspection 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 single sentence is efficient and has no filler, but it is under-sized for a tool with 10 parameters and no schema descriptions. This reads more as under-specification than as effective 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 with 10 parameters, no annotations, and no schema descriptions, a one-line description is inadequate. It offers no context about traversal scope, filtering, output limits, or how it complements sibling operations.

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 names none of the 10 parameters, leaving limit, max_bytes, include_ports, node_paths, and others entirely to their titles and defaults. The description adds no meaning beyond what the input schema already provides.

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

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

The description uses a specific verb ('Inspect') and a specific resource ('document-level Cinema 4D Scene Nodes graph'), and the 'document-level' qualifier distinguishes it from capsule-level inspection siblings. However, it does not state what the inspection returns or how it relates to edit/layout siblings.

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

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

There is no guidance on when to use this tool instead of edit_scene_nodes_graph, layout_scene_nodes_graph, or the capsule inspection tools. The 'document-level' wording weakly implies scope, but no explicit conditions, exclusions, or alternatives 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 carries the full burden. It says 'request native layout' but does not disclose what layout computation entails, whether it mutates anything, what preconditions exist, or what 'native' means in contrast to other tools. This is a significant gap for a tool that orchestrates graph layout.

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?

Single sentence, no fluff, front-loaded with the action ('Request native layout'). It is concise but may be too terse, leaving out valuable context.

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

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

The tool has 3 params, 0% schema coverage, no annotations, and this description explains none of the parameters or behavior.

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?

Input schema has 0% description coverage for graph_target, scope, and node_path Ess. The description gives no parameter guidance, forcing agents to guess the shape of graph_target and meaning of scope/node_path. The phrase 'one exact Capsule instance graph' faintly implies graph_target is an identifier, but it does not explain the required object structure, so the description fails to compensate for the schema gap.

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

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

The description names a specific verb ('request'), resource ('native layout'), and target ('one exact Capsule instance graph'), which distinguishes it from broader tools like layout_scene_nodes_graph. It is not a tautology and gives a clearer picture than a generic 'layout capsule graph' would.

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 siblings like inspect_capsule_graph, layout_scene_nodes_graph, or focus_capsule_graph. The phrase 'one exact' implies specificity, but there is no explicit statement of when to choose it or what it is not for.

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 nothing about whether the command is read-only or mutates the scene, whether it affects node positions, whether it requires specific context, or what side effects it has. The single sentence provides zero behavioral transparency.

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

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

The description is one sentence with no wasted words, but it is under-specified rather than concise. It lacks essential context, so it fails the 'appropriately sized' criterion. A 2 reflects that while it's not verbose, it's too sparse to be useful.

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?

Despite having an output schema (not shown), the description is grossly incomplete. It doesn't explain the command's effect, parameter usage, or when to apply it. For a tool with two optional parameters and a specialized domain, this level of description is inadequate.

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

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

Schema description coverage is 0%, and the description does not mention either parameter (scope, node_path). It gives no hint of what 'scope' means or how 'node_path' is used. The description entirely fails to compensate for the schema's lack of documentation.

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

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

The description states a specific verb ('Run') and resource ('Cinema 4D's native Scene Nodes layout command'), which is more than a tautology. However, it doesn't explain what the layout command actually does (e.g., arranging nodes, repositioning), and it doesn't distinguish this from the sibling 'layout_capsule_graph' or other graph tools. The purpose is recognizable but vague.

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. It doesn't mention that it applies only to Scene Nodes graphs, nor does it point to layout_capsule_graph or any other sibling. An agent would have to infer usage entirely from the name, with no help from the 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 burden. It discloses that the tool may return a validation error and suggests a fallback, which is useful behavioral context. However, it doesn't describe what the output looks like (though an output schema exists), nor does it mention any side effects or limitations beyond the error case. The error fallback hint adds some transparency, but more could be said about the tool'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 two sentences long, with the primary purpose front-loaded in the first sentence. The second sentence adds a practical fallback instruction. Every sentence earns its place; there is no fluff or repetition.

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

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

For a zero-parameter list tool with an output schema, the description is largely complete. It states what the tool does and provides a fallback for a known error case. It doesn't mention what the output schema contains, but the output schema itself is available to the agent. The only minor gap is not explaining what 'all objects' includes (e.g., nested objects, hidden objects), but this is a minor omission given the tool's simplicity.

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

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

The tool has zero parameters, so there are no parameter semantics to clarify. The description doesn't need to explain any parameters. The schema coverage is 100% (vacuously), and the description adds no parameter info because none is needed. A baseline of 4 is appropriate for a zero-parameter tool.

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

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

The description clearly states the tool's function: 'List all objects in the current Cinema 4D scene.' It uses a specific verb ('List') and resource ('objects in the current Cinema 4D scene'). It doesn't explicitly differentiate from siblings like get_scene_info, but the action is clear enough that an agent can infer its 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 provides a clear usage context: it lists all objects in the current scene. It also gives an explicit fallback instruction: if a validation error occurs, use execute_python_script to traverse the object hierarchy manually. This is a form of when-to-use guidance, though it doesn't explicitly state when NOT to use this tool in favor of other siblings like get_scene_info.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It only states the action without revealing side effects (e.g., whether the current scene is replaced), file format requirements, or error behavior. The agent has no information beyond the basic action.

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

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

The description is one action sentence plus an explicit Args block for the parameter. It is tightly written, front-loaded with the purpose, 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?

The tool is straightforward with a single parameter and has an output schema, so the description covers the basic invocation. However, it lacks useful context like file format expectations or whether loading overwrites the current scene. It meets the minimum viable threshold but does not go beyond it.

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

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

The schema itself gives 'File Path' as a plain string with no description, so the description adds meaningful semantics: 'Path to the scene file to load.' This tells the agent what the parameter means and how it is used, though it omits details like supported extensions or relative/absolute path conventions.

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 ('load') and a specific resource ('Cinema 4D scene file'), which clearly distinguishes it from sibling tools like save_scene and get_scene_info. The action is immediately understandable.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention that loading a scene is a prerequisite for other operations, nor does it state any exclusions or 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, and the description does not disclose side effects, whether properties are overwritten or merged, whether changes are undoable, or what error conditions may occur. 'Modify properties' only states the basic intent, not the behavior around it.

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

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

The description is short and front-loaded, with the core purpose in the first sentence. The Args block is compact, though the parameter summaries mostly restate the parameter names and add little beyond the examples.

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?

Basic inputs are identified, but an agent would still lack enough information to construct valid property values, understand coordinate spaces or units, or anticipate error behavior. The output schema may cover return values, but the description alone leaves significant operational gaps.

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

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

The schema only defines object_name and properties as raw names, and the description adds that properties is a dictionary containing things like position, rotation, and scale. That is helpful but incomplete: it omits accepted property names, value formats, units, and optionality.

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 ('Modify') and a clear resource ('properties of an existing object'), and gives example property categories (position, rotation, scale). It does not explicitly name sibling tools, but the phrase 'existing object' helps distinguish it from creation tools like add_primitive.

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 related scene-editing tools such as apply_material, set_keyframe, or group_objects. No alternatives, exclusions, or prerequisites are mentioned, leaving the agent to infer appropriate usage from 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 providedhare and the description gives minimal behavioral context. It doesn't state whether the render writes to disk by default, whether it is a side-effectful operation, what happens if output_path is omitted, or whether it blocks until completion.

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

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

The description is one clear sentence plus a tidy parameter list with each argument explained. It front-loads the core purpose 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?

The description does not explain how this tool relates to render_preview, when to choose this over other render/snapshot options, or what the output schema represents. Given the presence of a closely-named sibling and an output schema, the description lacks critical context for tool selection and invocation.

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

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

The Arg block adds meaning beyond the bare schema: it explains output_path as a save location and width/height as pixel dimensions, which is not evident from the schema alone. It doesn't document defaults or constraints, but since all parameters are optional, that's acceptable.

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 ('Render') and object ('the current frame'), making the tool's purpose easy to grasp. However, it does not explicitly differentiate itself from the sibling render_preview tool, which could be confused with this 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?

No guidance is given about when to use render_frame versus render_preview or other rendering alternatives. The context is implied by the name, but the description provides no exclusions or selection 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?

No annotations are provided, so the description carries the behavioral burden. It does disclose that the result is base64-encoded and that the operation relies on the current view, which suggests a read-only preview. However, it does not explicitly state that the scene is not modified, whether rendering is blocking, or whether any files are written, leaving some 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 concise and front-loaded, with a clear one-sentence purpose followed by a compact Arg list. There is no filler, and every sentence adds useful 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 tool with no required parameters and an output schema, the description covers the operation, parameters, and return encoding well. The main missing piece is guidance on how render_preview relates to render_frame or snapshot_scene, but invocation details are otherwise 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 description fully compensates by explaining all three parameters: width and height in pixels, and frame as the frame number to render. It also marks all of them as optional, adding meaning the bare schema does not 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 states a clear verb ('Render'), a clear resource ('the current view'), and a concrete output ('base64-encoded preview image'). It is specific enough to understand the tool's function, but it does not explicitly distinguish itself from the sibling render_frame, so it stops short of a top score.

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 render_preview versus render_frame, snapshot_scene, or other rendering-related siblings. The phrase 'current view' implies a preview use case, but no explicit when-to-use, 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?

No annotations are provided, so the description must carry the full behavioral burden. It only states 'save the scene' without disclosing effects such as whether it overwrites the file if it exists, whether it creates intermediate directories, whether it triggers a render or a ZBrush-like save, or what happens with unsaved documents. It also doesn't mention if the 'scene' is the entire project or just a sub-scene, leaving behavioral uncertainty.

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, consisting of a short sentence plus an argument description. However, it is under-specified rather than concise; the lack of detail is not an efficient use of space, but rather a missed opportunity to convey important context. The structure is adequate but not exemplary, as it doesn't front-load critical information like warnings or side effects.

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?

Despite having a simple schema (one parameter), the description is not complete because it lacks any mention of the output schema (which exists, indicating there is a return value), any error conditions, or any behavioral expectations. Since it's a mutation-like tool (save operation) with no annotations, the description should cover side effects and potential risks, which it does not. The adjacent sibling 'snapshot_scene' suggests there is a difference between saving and snapshotting, but this is not explained.

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 only one parameter, file_path, with a default of null. The description says 'Optional path to save the scene to', which adds a little context about the parameter's purpose (the path where to save). Since the schema already clearly indicates the parameter is optional and nullable, the description's value is marginal. With schema description coverage at 0%, the description does add some meaning but not much beyond what the schema's field name suggests.

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 saves the current Cinema 4D scene, which is a specific action on a clear resource. It doesn't explicitly distinguish from the sibling tool 'load_scene' or 'snapshot_scene', but the verb 'save' is distinct enough that the purpose is clear without being confused with loading or snapshotting.

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

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

The description does not provide any guidance on when to use this tool versus alternatives like 'load_scene' or 'snapshot_scene'. There is no mention of prerequisites (e.g., whether a scene must be loaded first), no mention of typical usage scenarios, and no indication of why one would choose this over a similar tool. The lack of usage context is a significant gap for an agent determining the right tool.

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

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

No annotations are provided, so the description must carry the burden of behavioral disclosure. It states it does not modify repositories, which is helpful, but it doesn't disclose return format, pagination behavior (though limit parameter suggests), or any side effects beyond non-modification. It is minimal.

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

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

The description is a single sentence that is efficient and front-loaded with the main action and scope. It briefly notes the non-modification aspect, adding value without fluff. It is concise and well-structured.

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

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

Given the tool has 4 parameters with zero schema description, and an output schema exists, the description should provide more context on how parameters influence the search and what the output represents. It only mentions the asset types and non-modification, leaving significant gaps for an agent to understand the tool's full behavior.

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

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

Schema description coverage is 0%, meaning the schema does not describe the parameters. The description mentions 'installed Capsule and NodeTemplate assets' but does not explain how 'query', 'category', 'node_space', or 'limit' affect the search. The limit parameter is inferred as a limit on results, but not stated. The description fails to compensate for the schema's lack of documentation.

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

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

The description states a specific action ('Search') and the resource ('installed Capsule and NodeTemplate assets'), and clarifies it does not modify repositories. However, it does not explicitly distinguish from the sibling 'search_scene_node_assets', though the resource type is different. This is clear but could be more precise.

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 'without modifying repositories' implies a read-only usage contextainer, and the tool name suggests it is for searching assets, distinct from modification tools like 'add_primitive' or 'modify_object'. However, no explicit when-to-use or when-not-to-use guidance is given, nor 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 provided, the description must carry the behavioral burden. It conveys that this is a read-only search over installed local assets, which is useful context. However, it does not mention filtering, result behavior, or any side effects, though the 'search' verb makes destructive behavior unlikely.

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

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

The description is a single, front-loaded sentence with no filler or redundant wording. Every word adds meaning, and it is appropriately sized for a simple search 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 an optional-parameter search tool with an output schema, this is nearly adequate: an agent can safely invoke it with no arguments and interpret the result from the schema. The main gaps are missing parameter semantics and the lack of any explicit relationship to sibling search or inspection tools.

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

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

Schema description coverage is 0% and the description mentions none of the three parameters. Query, category, and limit are somewhat self-explanatory from their names, but the description adds no guidance on how query matches assets, what category values are accepted, or how limit applies.

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

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

The description states a clear action ('Search') on a specific resource ('installed Scene Nodes NodeTemplate assets'). It adds 'NodeTemplate' and 'installed' beyond the tool name, narrowing scope and distinguishing it from sibling tools like search_capsule_assets and describe_scene_node_asset.

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 phrasing implies this tool should be used to find installed Scene Nodes NodeTemplate assets, but it gives no explicit when-to-use guidance or alternatives. The agent can infer the intended context, but the description does not say 'use this instead of search_capsule_assets' or explain when a direct asset description would be better.

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 side effects, but it only says it sets a keyframe. It does not state whether existing keyframes are overwritten, whether missing properties are created, or whether an animation track is required.

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 front-loaded with the main action, followed by a tight Args list. Every line adds relevant information 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?

Although an output schema exists and all parameters are listed, the description omits important context such as property-path syntax, accepted value types, frame conventions, and overwrite behavior. Without annotations, an agent lacks enough context 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 Args block is the only parameter documentation. It names all four parameters and gives an example for property_name ('position.x'), but leaves value type and frame semantics underspecified.

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 a keyframe for an object property.' It is specific enough for an agent to know the tool's purpose, though it does not explicitly distinguish itself from siblings such as animate_camera or modify_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?

No guidance is given on when to use this tool versus alternatives. The description only explains the operation and parameters, leaving the agent to infer the appropriate context 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?

No annotations are provided, so the description must carry the side-effect/safety burden. It does not state whether the snapshot modifies the current scene, whether it overwrites existing files, or what happens when file_path is omitted. The only behavioral hint is that external assets can optionally be included.

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, direct, and each sentence adds information: the purpose, the save path, and the asset-inclusion option. There is no fluff or irrelevant 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?

The description gives the core action and clarifies the two parameters, but it omits how a snapshot differs from 'save_scene', what happens when no file_path is supplied, and whether the operation is destructive or reversible. Given the large sibling set, an agent may struggle to pick this tool 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 schema provides only names and defaults with 0% coverage, but the description adds meaningful glosses: file_path is an optional save location, and include_assets toggles external asset inclusion. This is useful semantic content beyond raw parameter 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 states a specific action ('Create a snapshot') and a target ('the current scene state'), so an agent can tell it is a capture operation. However, 'snapshot' is not clearly distinguished from siblings like 'save_scene' or 'render_frame', so it is not a full 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 such as 'save_scene', 'load_scene', or 'get_scene_info'. No conditions, prerequisites, or exclusions are provided.

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