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

No annotations are present, so the description must disclose behavior. It states the return value (DescID nested list) and its intended use with other tools, which is helpful. However, it doesn't mention side effects (e.g., whether the slot is immediately added, if duplicates are allowed, or any failure modes). For a creation operation, this is a moderate gap but not severe.

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, both front-loaded with the core purpose. It efficiently conveys the operation, target, return value, and dtype list without fluff or repetition of schema details.

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

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

The tool has 8 parameters and no output schema, so the description's note about the return value (DescID nested list) and its integration with get_params/set_params is valuable. It also explains the 'dtype aliases' which map to the enum. While it doesn't cover all param semantics, the schema descriptions fill most gaps, and the description covers the key workflow context.

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

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

All 8 parameters already have descriptions in the schema, and the schema coverage is complete (100%). The description mentions the 'dtype aliases' but doesn't elaborate on min/max/step semantics beyond what the schema provides. Since the schema does the heavy lifting, the description adds minimal value, earning a baseline of 3.

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

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

The description clearly states the operation ('Add a new User Data slot'), the target ('any BaseList2D'), and the typical use case ('common rigging / control-exposure pattern'). This gives an agent immediate understanding of what the tool does and when it might be relevant.

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

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

The description explains the return value and its intended use with get_params/set_params, but it does not provide any guidance on when to use this tool versus alternatives, prerequisites, or potential failure conditions. Since there are no annotations to fill this gap, the description is minimally adequate but lacks actionable usage direction.

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

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

The description explains the declarative syntax, the ability to create or mutate, the default create_graph=true, and the special notes for scenenodes (asset IDs, limitation on queries/labels). It does not mention return values or error conditions, but given the complexity, the core behavior is well-transparent. No annotations exist to contradict.

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 fairly long but well-structured: it starts with the main purpose, includes an inline example, then details the scope and node_space differences. It is front-loaded with the essential purpose and uses clear phrasing, though some redundancy exists (e.g., repeating the example).

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

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

Given the tool's complexity, the description covers most necessary context: the dict syntax, scope handling, node_space aliases, and the scenenodes specifics. It does not mention return values or error handling, but with no output schema and the complexity, it is reasonably complete for an agent to invoke correctly.

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

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

The schema covers all 5 parameters with individual descriptions, and the tool description adds meaningful context beyond the schema: the example shows the nested $type/$id structure, the difference between node spaces, and the requirement for handle unless scope:document. This adds value on top of the 100% schema coverage.

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 builds or mutates a node graph using a declarative dict syntax, and lists the supported operations (creating nodes, assigning ids, wiring connections, setting port values). It is distinct from sibling tools like list_graph_nodes which only read graphs, and the example clarifies usage.

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 concrete example and explains when to use document scope vs material scope, as well as the distinction between standard/redshift and scenenodes. It states the required handle unless document scope and the default create_graph behavior. However, it does not explicitly contrast with alternative tools (e.g., set_graph_port), leaving some inference needed for selection.

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

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

No annotations exist, so the description carries the full disclosure burden for a clearly mutating tool (creates nodes, connects ports, optionally auto-adds a Texpresso tag). It does disclose these creation side effects and hints that EventAdd follows, which is useful. But it omits whether an existing graph is replaced or appended to, any permission constraints, and what the call returns — notable gaps for a mutation with zero annotation coverage.

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

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

A dense but efficient paragraph that front-loads purpose, then sibling differentiation, then operator_id syntax, then tag-creation, ending with a concrete example. No wasted sentences. The long alias list is arguably overpacked but justified by the tool's complexity; it reads as information-dense rather than padded.

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

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

For a complex tool with deeply nested objects and no output schema, the description covers a lot: aliases, tag creation, and a full workflow example. Yet it leaves material gaps for an agent — the return format/confirmation, replace-vs-append semantics on an existing graph, and error behavior. Given the tool's complexity, these omissions prevent a higher score.

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

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

Schema coverage is 100%, so the schema already documents all four parameters with descriptions. The description adds concrete value beyond the schema via the operator_id alias enumeration ('object'|'const'|'result'|...) and the ID_OPERATOR_CONST=1001150 example, but much of the content (the node spec, port-selector priority, Connect semantics) duplicates schema text. This fits the baseline-3 for high schema coverage.

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-plus-resource ('Declarative builder for an Xpresso graph... Creates nodes... and wires connections') and explicitly differentiates from the sibling apply_graph_description — 'mirror of apply_graph_description but for Xpresso rather than Maxon node materials.' An agent can distinguish this from its sibling without opening either schema.

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

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

The mirror phrasing establishes the selection context (Xpresso/GvNodeMaster vs. Maxon node materials) and the example workflow (create Cube → apply_xpresso_graph → EventAdd) conveys practical sequencing. However, it never states an explicit 'when NOT to use' or names the alternative outside the brief mirror clause, leaving some inference to the agent.

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 (empty {}), the description carries the full burden. It discloses the core behavior (create/update Texture tag) and the projection preservation behavior, but does not mention what happens to existing tags when update_if_exists is false (presumably appends), error handling, or side effects. This is adequate for a simple operation but lacks depth.

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

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

Two sentences plus a compact list of projection aliases. The core action is front-loaded, the benefit is concise, and the list is useful. No wasted words.

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

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

Given the tool's moderate complexity (8 params, 2 required) and no output schema, the description covers the essential behavior and key options. It lacks explicit info on error conditions or return values, but for a simple material assignment, the schema handles the rest. It is complete enough for correct invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds marginal value by mentioning projection aliases and the update_if_exists purpose, but these are already clear in the schema. It does not significantly augment parameter understanding beyond what the schema 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 clearly states the verb 'Link' with a specific resource: material to object via Texture tag creation/update. It distinguishes itself from general entity tools and mentions the update behavior, making its purpose unambiguous.

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

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

The description explains that it 'Avoids wrangling TEXTURETAG_* param ids by hand', which implies a manual alternative, and specifies the update_if_exists behavior. It does not explicitly name alternative tools or conditions for not using it, but the context is sufficient for an agent to decide when to invoke it.

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

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

With no annotations, the description carries the responsibility for disclosing effects. It explains that the tool places a target on a layer and can clear the assignment via null, covering the primary behavior. It does not detail side effects or reversibility, but the core behavior is transparent.

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

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

The description is two concise sentences with no unnecessary words. It efficiently conveys the action, the null handling, and a key precondition.

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

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

Given the simple interface (two parameters, no output schema), the description is sufficient. It explains the target, layer behavior, and a necessary precondition. It does not discuss error cases or return values, but these are not required for basic usage.

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

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

The schema already provides descriptions for both parameters, and the description adds clarity by specifying target types and the null semantics for layer. This goes slightly beyond the schema, adding useful context without redundancy.

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 (place target on layer), specifies the target types (object/tag/material), and explains the special case of null to clear assignment. It is specific 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 includes a usage note about the layer needing to exist, suggesting calling create_layer first. This provides a precondition but does not explicitly compare with alternative tools or state when not to use it.

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

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

With no annotations to carry the safety/behavior burden, the description discloses three key behavioral traits: operations apply in order, failures are recorded per-op while the batch continues by default, and the entire batch is wrapped in a single undo group. These details are critical for an agent to predict the tool's side effects accurately.

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

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

Three sentences, each dense with information: purpose, execution semantics, and a concrete workflow example. There is zero fluff; every word contributes to understanding or differentiation.

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 composite operation with no output schema, the description fully equips an agent to decide when to use it and what to expect regarding ordering, error handling, and undo behavior. It also addresses the main caveat (nested batch restriction) within the schema, and the workflow suggestion ties into the broader tool ecosystem.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explaining the op types (through examples of handler names) and hinting at the workflow for populating them. It doesn't detail individual argument structures, but combined with the schema, the agent has sufficient clarity.

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 begins with a specific verb and resource ('Run many generic ops in one RPC'), immediately distinguishing it from singular sibling tools like set_params or create_entity. It also clarifies scope by explaining the sequential application, error handling, and undo grouping, making it unmistakable what this tool does.

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

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

The description provides a clear use case ('apply X to all matching entities') and explicitly recommends pairing with list_entities and name_pattern to obtain handles. However, it does not explicitly state when NOT to use this tool or name an alternative, missing the full 'when-not/alternatives' criterion.

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 empty annotations, the description carries the full transparency burden, but it only references the underlying c4d.CallCommand() mechanism and lists example commands. It does not disclose side effects, blocking behavior, potential data loss (e.g., 'Make Editable'), undo implications, or error behavior — significant for an arbitrary-command passthrough.

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

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

Two efficient sentences with the verb+object front-loaded. The first sentence states what the tool does; the second narrows scope with useful examples. No wasted words.

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

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

For a 3-parameter tool whose schema covers each parameter well, the surface is simple and mostly adequate. However, as a passthrough to arbitrary commands with no annotations or output schema, the description omits warnings about long-running or destructive commands (the schema hints at sync behavior in timeout_ms, not the description), leaving clear gaps for an agent deciding whether 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 coverage is 100%, so the schema already documents command_id, subid, and timeout_ms well, including ID examples, discovery via list_plugins, and a default timeout. The description adds marginal value by categorizing built-in commands, matching the baseline 3 when the schema does the heavy lifting.

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

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

The description gives a specific verb+resource: 'Invoke a Cinema 4D command by plugin id via c4d.CallCommand()', with concrete examples of the commands it runs (render, save, make editable). It does not explicitly differentiate itself from siblings like modeling_command, render, or preview_render, so it misses the top mark, but the purpose is unambiguous.

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

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

No guidance is given for when to pick this tool over the 77 siblings; 'Works for built-in commands ... and any registered command plugin' describes scope of supported commands rather than when to use this tool vs. alternatives like render or save_document. No exclusions, prerequisites, or 'use X instead' hints 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?

With no annotations, the description carries the behavioral burden and reveals meaningful traits: API-specific behavior per type (GetClone, InsertRenderData, AddTake), copying of VideoPosts/overrides, parent defaulting, and return of a handle. It doesn't discuss side effects like whether child objects are duplicated, but it goes well beyond a bare 'duplicate entity'.

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?

Every sentence adds information: operation, supported types, type-specific mechanics, default placement, and return value. It is dense but front-loaded and free of 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 complex multi-type tool with no output schema, it covers all entity kinds, parent behavior, defaults, and return type. Nothing essential is missing for an agent 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 coverage is 100%, so the baseline is 3, but the description adds meaningful default behavior for parent and clarifies destination semantics per entity type. It also confirms the return handle, which complements the handle 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 opens with 'Duplicate an entity', a specific verb and resource, then enumerates the supported entity types (object/tag/material/shader/render_data/video_post/take). This cleanly differentiates it from creation tools like create_entity and from query tools like list_entities.

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

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

It states the operation clearly and gives type-specific context, such as 'Objects default to dropping next to the source; pass `parent` to place the clone elsewhere', so an agent can infer when to call it. It does not explicitly name alternatives or exclusion conditions, but the sibling set makes the use case evident.

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 goes well beyond the destructiveHint annotation by specifying that closing discards unsaved work, the tool refuses without force, and C4D always keeps at least one document open. It discloses the edge case of closing the last document, which is valuable behavioral information an agent cannot infer from annotations alone.

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

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

Three sentences with every sentence earning its place: how to identify the document, the force behavior and data-loss warning, and the last-document edge case. The most important information is front-loaded.

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

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

The description covers all key behaviors an agent needs: parameter selection rules, unsaved-change handling, force semantics, and the always-at-least-one-document behavior. With no output schema and a single destructive action, this is sufficient context for correct invocation and user-disclosure.

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

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

The schema already documents each parameter thoroughly (100% coverage), so the baseline is 3. The description adds critical constraint that exactly one of `index` or `name` must be passed, which is not captured by the schema's required fields. This is meaningful extra guidance, though not extensive.

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 closes an open document, with the precise mechanism of identification (list `index` or `name`) and the constraints. It is immediately distinct from sibling tools like open_document, new_document, and save_document.

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

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

The description provides clear operational guidance: pass exactly one identifier, use `force:true` only to discard unsaved changes, and be aware that closing the last document leaves an empty one. It does not explicitly name alternatives or when to prefer save_document over close, so it slightly misses the 'explicit alternatives' bar.

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 empty, so the description carries the behavioral burden. It discloses the return value contract, notes that object handles include a stable `path`, and indicates chaining with set_params / set_keyframe. It also clarifies a non-obvious limitation: kind:'shader' only covers classical shader chains. It does not discuss failure modes or validation, but it is substantially more transparent than typical create tools.

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?

Four sentences, all front-loaded and purposeful. The first sentence states the core purpose, the second states the return contract, the third gives an essential routing caveat, and the fourth clarifies video_post behavior. No filler or redundant restatement of the schema.

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

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

For a broad multipurpose constructor with no output schema, the description covers the essential return/handle behavior and diverts edge cases to the right alternative. The schema covers parameter detail. Minor gaps remain around error/failure behavior and the exact shape of non-object handles, preventing a 5.

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 100%, so the baseline is 3, but the description adds semantic value beyond the schema: it explains kind-specific behavior for shader vs node materials, gives concrete video_post type_id examples, clarifies parent requirements, and describes the purpose of slots and params. This is more than repetition of structured fields.

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?

Begins with 'Unified constructor for object / tag / material / shader / video_post' — a specific verb, resource list, and clear scope. It also differentiates from related tools by naming when apply_graph_description is the correct alternative, so an agent can immediately understand what create_entity is and is not.

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

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

Explicitly directs the agent to apply_graph_description for node-material edits instead of kind:'shader', and explains that kind:'video_post' attaches renderer effects to a RenderData parent. This gives concrete routing guidance among siblings rather than leaving usage to inference.

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

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

With no annotations, the description carries the behavioral burden. It discloses the idempotent update behavior and the configurable fields, but it fails to state what happens when a layer with the same name exists and update_if_exists is false (e.g., error, duplication, or overwrite). This is a meaningful gap for a create/update operation.

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

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

Three tight sentences: purpose first, then the key behavioral nuance (update_if_exists), then configuration parameters. Every sentence earns its place with zero fluff.

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

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

The tool has a nested flags object and no output schema, so the description must cover the essentials. It explains creation, idempotent update, and parameter usage, but omits critical edge-case behavior (what if the name already exists without update_if_exists?) and any mention of return values or errors. Given the moderate complexity, it is adequately complete but has clear gaps.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds the 'and/or' relationship between color and flags and reiterates the color format and flag examples, but most parameter meaning is already in the schema. No significant extra clarification is provided.

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

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

The description opens with 'Create a LayerObject at the document's layer root,' which clearly specifies the verb, resource, and placement. This distinguishes it from sibling tools like list_layers and create_entity, as it is the only one that mentions LayerObject creation at the root.

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

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

The description gives clear context: you use this to create a layer, optionally updating an existing one via update_if_exists. It does not explicitly mention alternatives or when not to use it, but the purpose is unambiguous enough for an agent to select it correctly among siblings.

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

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

With empty annotations, the description carries the burden and is fairly transparent: it discloses the C4D call used, that creation is one call, that markers can be named, and that the call returns marker info including an index handle. It does not detail failure conditions or permissions, but for a create operation with a stated return value this is a minor 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?

Three dense sentences front-load the core behavior, then add rationale and return-value context. No filler or repetition of schema fields.

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

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

There is no output schema, but the description supplies the important return detail (marker info with an index handle for follow-up tools). Combined with 100% parameter schema coverage, an agent has enough context to call this correctly.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters with defaults and mutual-exclusion notes. The description adds only a light summary ('optional colour and length', 'frame (or time in seconds)') rather than new parameter meaning.

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 ('Create') and resource ('named timeline marker'), and specifies frame/time positioning plus optional color and length. It distinguishes create_marker from sibling operations by noting the returned index is intended for set_marker/remove_marker.

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

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

It explicitly says this replaces the old playhead-seeking workaround and explains why (that approach could only create unnamed markers). It also routes subsequent edits/deletes to set_marker/remove_marker via the returned index.

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 empty, so the description carries the full burden. It discloses the upsert semantics (update-if-exists) and the return value, which is genuinely useful. However, it does not state behavior on conflict when update_if_exists=false and a name already exists, or any error/permission implications for a mutation tool with zero annotation coverage.

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

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

A single two-clause sentence carries the purpose, the upsert behavior, the scope of settings, and the return value with zero filler. Everything earns its place and the central action is front-loaded.

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

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

For a 12-parameter tool with no output schema and no annotations, the description covers the core purpose, return value, and downstream usage. With full schema coverage carrying parameter meanings, the only meaningful gap is the unspecified behavior when update_if_exists=false collides with an existing name — minor given the required name param provides a natural key.

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

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

Schema description coverage is 100% — every one of the 12 parameters has its own schema description — so the baseline of 3 applies. The description only maps the high-level fields (resolution/renderer/fps/frame range) to parameters and adds the handle-return semantics; it does not add syntax or format details 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 specific verb+resource ('Create (or update-if-exists) a RenderData') with named fields (resolution/renderer/fps/frame range) in one call. It also names downstream sibling tools (create_take/set_params) for chaining, distinguishing the tool's role from other entity-creation tools in the sibling list.

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 hints at usage context by noting the returned handle enables create_take/set_params chaining and that the call consolidates multiple settings 'in one call,' but it never explicitly states when to prefer this over alternatives or when not to use it. No exclusions or alternative-routing guidance is given.

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

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

With no annotations, the description must carry the behavioral burden, and it does: it reveals the internal operation composition, the checked-by-default batch-render behavior, and the take-handle return value. It does not cover what happens when a duplicate name exists and update_if_exists is false, but the schema parameter description partially fills in that 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?

Two tight sentences deliver the core capability, default behavior, return value, and a recommended use case without filler. The primary capability is front-loaded before secondary details, and every clause earns its place.

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

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

The description covers the essential call semantics, the checked default, and the returned handle, which matters because there is no output schema. The main gaps are duplicate-name behavior when update_if_exists is false and any prerequisites for parent/camera/render_data, but the comprehensive per-parameter schema descriptions prevent these from being major omissions.

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 100%, so the schema already documents all nine parameters and earns a baseline 3. The description adds some semantic value by connecting camera/render_data/checked to the SetCamera/SetRenderData/SetChecked operations and explaining checked's batch-render effect, but it is not required to compensate for missing schema info.

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 precise verb-resource pair — 'Create or update a Take' — and lists the exact bundled operations (AddTake + SetCamera + SetRenderData + SetChecked), making it clearly distinct from single-purpose siblings like take_override or create_render_data. It also explains the checked default and the returned handle, further specifying the tool's uniqueness.

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 'ideal for building per-shot take stacks programmatically' gives a clear use context, and the checked-by-default explanation tells when to pass checked:false. It does not explicitly name alternative tools or state when not to use this tool, so it stops short of a 5.

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

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

Annotations provide destructiveHint=true, and the description adds context beyond that: it specifies the deletion modes (single vs inclusive range), the return shape '{removed, track}', and the symmetric relationship with set_keyframe. It does not contradict the destructive annotation.

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

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

Three short sentences; the purpose is front-loaded, and each sentence carries distinct information: what it does, how to specify the target, and what to expect in return. 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?

The description covers the core operation, deletion modes, and return shape, but leaves ambiguity around the optional frame/start_frame/end_frame parameters: schema marks them optional, yet the description does not state what happens if none are provided or if both single and range are given. It also does not describe how 'component' applies to vector tracks, though the schema partially covers 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 coverage is 100%, so the baseline is 3. The description adds value by clarifying the mutually exclusive mode: 'frame' for single, 'start_frame'/'end_frame' for a range, and by noting inclusivity. It also mentions the return object, which is not in the schema.

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

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

The description states the exact action ('Remove keys') and the resource ('a CTrack'), which goes beyond the title and clearly distinguishes it from sibling tools like delete_track (removes whole track) and set_keyframe (adds keys). The operation 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?

It gives clear usage context by distinguishing single-frame deletion with 'frame' versus range deletion with 'start_frame'/'end_frame'. It names set_keyframe as the symmetric counterpart, which helps an agent choose between adding and removing keys, but it does not explicitly state when not to use this tool (e.g., 'use delete_track to remove an entire track').

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

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

The destructiveHint annotation already flags mutation, so the description's job is lighter. It adds some value by disclosing the return shape ({removed: bool}) and clarifying that removal is keyed by param_id + component, but it does not state whether deletion is irreversible or that all keyframes on the track are destroyed as a consequence.

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

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

Two short sentences with zero waste: the first leads with the action and identification strategy, the second gives the return value. Every word earns its place.

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

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

For a 3-param destructive tool with 100% schema coverage and a destructiveHint annotation, the description is nearly complete: it states the target, the identifying parameters, and the return value (compensating for the missing output schema). It falls slightly short on the semantics of a false result (track not found?) and on routing to sibling 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 100%, so the baseline is 3. The description reinforces the combinational semantics of param_id + component for identifying the track, which slightly augments the schema, but it adds no genuinely new parameter meaning beyond what the schema properties already document.

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 ('Remove') and a specific resource ('an entire CTrack'), and names the exact identification key (param_id + optional component). 'Entire' sets it apart from the sibling delete_keyframe, which removes individual keyframes, so an agent can tell them apart without opening the schema.

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

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

Usage context is implied rather than stated: 'entire CTrack' hints that this is for whole tracks, not individual keyframes, but the description never explicitly names delete_keyframe as the alternative for partial removal. No guidance is given on how to discover param_id (e.g., via list_tracks).

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 readOnlyHint=true provided, the description is consistent (no contradiction) and the safety profile is already covered by annotations. The description adds value by specifying output fields and the handle-resolution behavior, but never discloses error behavior for invalid handles or edge cases. This is adequate but not rich additional context beyond the annotations.

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

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

The main description is two tight sentences with zero filler, front-loading the verb 'Dump' and enumerating exact output fields. The parameter description is long, but every clause earns its place given the complexity of nine handle shapes, and the {' — '} parentheticals pack in workflow guidance without bloat.

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

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

For a read-introspection tool with a single parameter and no output schema, the description is nearly complete: it documents output fields, handles all nine resolution shapes with examples, and integrates with the sibling-tool workflow (list_xpresso_nodes, set_params, save_document). The only minor gap is that error behavior on invalid handles is not disclosed, but nothing essential is missing for an agent to call this correctly.

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

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

Schema coverage is 100%, setting baseline at 3, but the description adds substantial meaning beyond the JSON Schema's anyOf shapes: concrete format-alias examples ('abc'/'fbx'/'obj'), the gv_node BaseList2D inheritance note, and the plugin_type default ('scene_saver'). The advice to prefer path over non-unique names is a genuinely useful semantic that the schema could never convey.

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: "Dump all description parameters (id, name, cycle enum, current value) of a C4D entity resolved by handle." The output fields are enumerated, and the line "Use this to discover parameter IDs before reading/writing" clearly positions this as the discovery tool within the parameter-access family, distinguishing it from get_params/set_params.

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

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

"Use this to discover parameter IDs before reading/writing" provides explicit when-to-use context. The gv_node parameter help names a sibling (list_xpresso_nodes) with an explicit condition, and the plugin_options tip lays out a workflow ("describe+set_params it... before save_document"). However, the main description never explicitly contrasts describe with get_params or states when not to use it.

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

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

Beyond readOnlyHint, description details output transformations (type_id, type_name, name, file, file_candidates, linked_shaders) and explains why Fusion/Colorizer shaders need this tool. Adds substantial context without contradicting annotations.

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

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

Dense but focused: purpose, scope restriction, output details, and discovery tip in ~120 words. Front-loaded with clear purpose, each sentence earns its place, though slightly long for a simple 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?

With no output schema, description compensates by enumerating captured fields and scope restrictions. Covers recursion depth and handle requirements, making it sufficiently complete for an agent to call correctly.

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

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

Schema coverage is 100% with detailed descriptions for both handle and max_depth. The description adds no new parameter syntax, only contextual usage tips, so baseline 3 is appropriate.

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 explicit verb and resource: 'Recursively dump a shader into JSON'. Distinguishes from siblings by mentioning node materials are handled elsewhere, making scope 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?

Explicitly states 'Classical materials only' and directs to list_graph_nodes/apply_graph_description for node materials. Also advises pairing with list_entities to discover handles, covering when and how to use.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds useful behavioral context, that this exposes raw keys not shown elsewhere and that output can be filtered by key range. It does not go into output size, formatting, or default range behavior, but the annotation lowers the burden on 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 compact and front-loaded, stating what the tool does in its first clause. The added example about Oct 2 AOV shader slots earns its place by clarifying why raw hidden-key access is valuable.

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, read-only, and its key parameter is thoroughly documented in the schema. With no output schema, the description could have included a bit more detail about the return shape, but 'dump raw BaseContainer' strongly implies what the response will contain, and the filtering guidance helps agents manage output size.

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 100%, so the schema already documents all three parameters including the handle shape in detail. The description adds some context by calling out key-range filtering, but it doesn't meaningfully supplement the parameter semantics beyond what the schema already provides.

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

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

The description clearly states the tool dumps the raw BaseContainer of a C4D entity, a specific verb and resource. It also distinguishes the tool from `describe` by calling out hidden keys that don't appear there.

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 indicates when to use this tool, specifically when raw or hidden container keys are needed, and gives a concrete use example (Octane AOV shader slots). It also suggests filtering by key range to narrow output, which helps control scope. It doesn't explicitly state exclusions or direct users to alternative tools, but the use case guidance is clear enough.

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

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

Annotations already declare readOnlyHint=true, and the description does not contradict this. It adds behavioral context by specifying that it returns canonical handles and a marker_count, and notes it is a one-shot read (no pagination). This exceeds the annotation coverage and gives the agent expected output shape, though it stops short of detailing exact return types 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?

Two sentences with zero filler. The first sentence front-loads the purpose and enumerates the returned fields; the second sentence provides the sibling and writer counterparts. Every clause earns its place, making it both 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?

For a parameterless getter with no output schema, the description covers all essential return fields (fps, range, handles, marker_count) and links to related tools for further actions. It is complete for an agent to invoke correctly and interpret the result without additional context.

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

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

With zero parameters, the schema coverage is trivially 100%, so the description is not required to document parameters. Per the rubric, a 0-parameter tool gets a baseline score of 4. The description appropriately focuses on output semantics rather than inputs, adding value without redundancy.

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 reads key document fields (fps, frame range, current frame, etc.) and explicitly distinguishes it from related siblings by mentioning list_markers for marker listing and set_document as the writer counterpart. This leaves no ambiguity about what the tool does or how it differs from similar tools.

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

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

The description implies usage context by calling it a 'one-shot reader' and points to list_markers for listing markers and set_document for writing, giving a clear sense of when to use this tool. However, it doesn't explicitly state 'use this when you need the current state in one call' or mention exclusions, but the intent is clear enough for an agent to pick 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?

Annotations already declare readOnlyHint=true, and the description reinforces this by using 'Report' as the verb. It adds context about the alias table and addressability, which goes beyond the annotation. No contradictions and it clarifies the informational nature of 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 two sentences with no wasted words. It front-loads the action ('Report') and immediately explains the purpose and context, while keeping the alternative tool reference concise.

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 lacking an output schema, the description specifies exactly what the tool returns: node spaces, active one, and alias table. This is sufficient for an agent to call the tool and interpret the output, similar to the high reference case. The description is complete for a read-only informational tool.

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

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

The single parameter 'handle' is already described in the schema as 'Material handle.' The description does not add any additional details about the parameter beyond what's in the schema, so it does not exceed the baseline established by the 100% schema coverage.

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 what the tool does: report which node spaces a material exposes a graph in, which is active, and the alias table. It uses a specific verb 'Report' with a specific resource 'material' and distinguishes itself from apply_graph_description by naming it as a follow-up 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?

The description explicitly instructs when to use the tool: 'Use this before apply_graph_description to confirm the right node_space is addressable.' This provides a clear usage context and points to the related tool, giving the agent explicit guidance on when this should be invoked.

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 readOnlyHint annotation already signals a safe read, and the description stays consistent by saying 'Read'. It adds value beyond the annotation by disclosing the exact return shape and the inclusive range-clipping behavior of start_frame/end_frame.

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

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

Three sentences carry all the essential information: what the tool does, how to find the right track, what it returns, and the optional range behavior. There is no repetition of schema boilerplate and no wasted wording.

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

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

For a read-only query tool with complete schema descriptions and a readOnlyHint, the description covers the key usage context: track discovery via list_tracks, return format, and range clipping. Nothing essential is missing for an agent to select and invoke this tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds useful semantics by framing param_id and component as a pair identifying an animated track and by restating that start_frame/end_frame clip inclusively, which reinforces the schema's own field 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 verb ('Read'), a specific resource ('keys on a specific animation track'), and the return shape. It also mentions the parameter pairing (param_id, component) that is central to identifying the track, so it is easy to distinguish from sibling tools like set_keyframe or delete_keyframe.

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

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

It explicitly tells the agent to combine this with list_tracks to discover which (param_id, component) pairs are animated, which is clear usage context. It does not explicitly enumerate alternatives to avoid, but the read-only purpose is obvious against the write/delete siblings.

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

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

The description discloses the read-only nature implicitly and adds detail about the output format (index tuples), the caps (50k default), and the requirement for editable objects. It goes beyond the readOnlyHint annotation by explaining the data structure and limits.

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 concise sentences. It front-loads the primary purpose and packs the essential constraints (editable object, format, caps) without redundancy or unnecessary details.

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

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

Since no output schema is present, the description compensates by describing the return format (triangles as [a,b,c], quads as [a,b,c,d]) and the cap behavior. It does not mention error scenarios or edge cases, but for a read operation that is acceptable.

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

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

Schema coverage is 100% with descriptions for all four parameters. The description reinforces the default values for max_points and max_polys (e.g., 'Default 50000') and clarifies the purpose of the include extras, but these are already in the schema. It adds little beyond what the schema 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 clearly states the specific action ('Read points and polygons (or spline segments)'), the target resource ('editable PointObject / PolygonObject / SplineObject'), and the format of the returned data. It distinctly separates from siblings like set_mesh (write) and set_mesh_selection.

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 practical guidance: primitives must be made editable via `modeling_command make_editable`, and notes the default count caps with overrides. It could be improved by explicitly contrasting with write operations, but the condition 'must be editable' is a strong usage signal.

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

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

The readOnlyHint annotation already establishes this as a non-mutating operation. The description adds the null return case and the notion of 'currently assigned', which clarifies the dynamic nature of the query. However, it does not disclose error behavior or edge cases, such as what happens if the target doesn't exist. Given the annotation covers the safety profile, this is adequate but not more.

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, succinct sentence that front-loads the core action and includes the key return behavior. Every word serves a purpose, and there is no redundancy. This is a model of conciseness.

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

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

For a getter tool with a single parameter and no output schema, the description provides sufficient context: what it returns, what input it needs, and the null case. One could ask for more detail on error handling, but the simplicity of the tool means this is nearly complete. It doesn't describe the return type (e.g., string vs. ID), but that's often self-evident from the domain.

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 parameter has a description ('Entity to query.'), giving 100% coverage and setting a baseline of 3. However, the description's parenthetical '(object / tag / material)' provides an incomplete list of acceptable kinds, omitting valid kinds like 'take', 'shader', and 'video_post' from the schema. This could mislead an agent into thinking only those three kinds are supported, potentially causing the tool to be underused or misused.

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 ('Return'), a clear resource ('the layer'), and a clear scope ('currently assigned to a target entity'). It distinguishes itself from siblings like 'list_layers' by focusing on querying a single entity's layer rather than enumerating all layers. This makes it unambiguous which action the tool performs.

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

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

The description implies when to use this tool (to get the layer of a specific entity) but does not explicitly mention alternatives or situations where one would not use it. For instance, there's no note about not using it for listing layers or for getting other properties. The usage context is clear but not explicitly delineated, so a 3 is appropriate.

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

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

The description adds meaningful behavior beyond the readOnlyHint annotation by disclosing the return envelope `{values: [{path, value}]}`, preservation of request order, dtype inference rules, and the explicit dtype override syntax. It does not address invalid-id or missing-parameter behavior, which is a minor transparency gap. No contradiction with the readOnlyHint annotation.

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

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

The description is compact and well-structured: one opening purpose sentence, two sentences for id forms, one for return shape, and one for discovery workflow. Every sentence earns its place and nothing is redundant.

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

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

Combined with the schema's detailed handle shapes, the description gives an agent enough to call the tool correctly: id syntax, return format, ordering, and the path for discovering ids. The only missing context is edge-case behavior such as unknown ids or missing values, which prevents a perfect score.

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

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

Although the schema covers both parameters, it only provides a raw union type and a terse description. The tool description supplies the operational meaning: ints are top-level, lists are chained DescIDs, 'x'/'y'/'z' denote vector sub-components, and explicit dtypes use the nested form. The concrete example `[903, 'x'] = position.x` makes the semantics actionable.

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 read operation: 'Read parameter values on a C4D entity by id or DescID path.' This specific verb and resource distinguish it from siblings like set_params and describe without requiring schema inspection. The purpose is unambiguous and action-oriented.

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

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

The description gives clear usage context, especially the discovery workflow: 'Discover ids via describe.' The read-only framing also implicitly distinguishes it from set_params. However, it does not explicitly name alternatives or state when not to use this tool, so it falls just short of complete usage guidance.

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

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

Annotations provide readOnlyHint=true, so an agent already knows it's safe. The description then adds value by disclosing the returned data types (active object as primary, all selected objects, active tag/material) and the guarantee that handles are canonical and can be piped into other tools. It doesn't go deeper into rate limits or error cases, but it doesn't need to.

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

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

Three sentences, all dense with information: what you get, why it's useful, and a note on output format. No filler, no restating of the tool name.

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

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

For a zero-parameter read-only query, the description is complete. It captures the return values and the primary use case (reacting to user's current focus). It could theoretically describe the data shape in more detail, but given the lack of output schema, the description does 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 tool takes 0 parameters and the schema coverage is 100%, so there is no ambiguity. The description even mentions the underlying mechanism (canonical handles) that makes the output useful for chaining. Nothing is left undefined.

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?

Uses a specific verb+resource combination ('Read the active document's current selection') that clearly defines both action and scope. Names the primary entity, the full selection set, and two special cases (active tag, material), which distinguishes it from generic 'get' tools. The phrase 'without asking them to re-pick entities' positions it against interactive workflows.

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?

Delivers clear context: it is for reading the current selection and piping into describe/set_params/etc. This implies when it's the right tool (selection-reading) and names follow-on tools. The exclusion is inferable from context rather than explicit 'use X instead,' so it misses a full 5.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the mutation of the active document, the return of top-level objects, and the optional re-parenting/renaming side effects. It does not discuss failure modes or undo semantics, but the core behavior is transparent and specific.

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

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

Two well-structured sentences: the action and return value come first, followed by optional behavior. Every clause earns its place, and there is no repetition of schema details 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 no output schema and no annotations, this description does most of the work: purpose, target document, return value, and optional parameter effects are all covered. It leaves the requirement of an active document implicit and does not enumerate every supported format, but the schema fills parameter shape and the chaining hint completes the practical picture.

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?

All four parameters are already described in the schema, so the baseline is 3. The description adds real value by explaining that 'parent' moves the newly imported top-level objects under an existing object and that 'rename' only affects the first root, which is not inferable from parameter names alone.

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

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

States a specific verb (merge/import), the resource (external file), the target (active document), and even the underlying method (MergeDocument). It also tells what is returned and which sibling tools the output can be chained with, making it clearly distinct from open_document or new_document.

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

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

The description clearly establishes the use case: merging external files into the active document while keeping the scene open, and the returned objects are explicitly meant for chaining. It does not name alternative tools explicitly or state when not to use it, but the context is unambiguous enough for selection.

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

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

The annotations already declare readOnlyHint=true, so the read-only nature is covered. The description adds valuable behavioral context by detailing the returned fields, especially that the list index is the handle accepted by set_active_document and that active-document status is included. This goes beyond what the annotation alone conveys.

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

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

Three sentences with no wasted words: the first states the action, the second defines the output, and the third gives the contrasting sibling. The most important information is front-loaded.

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

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

For a zero-parameter, read-only enumeration tool with no output schema, the description fully equips an agent to call it correctly and interpret the result. It explains the index handle, the fields, and how it relates to set_active_document and get_document_state. Nothing essential is missing.

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

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

There are zero parameters, so the schema imposes no ambiguity and the baseline is 4. The description does not need to explain any parameters, and it correctly focuses on output semantics instead.

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 ('Enumerate') and resource ('documents currently open in Cinema 4D'), and lists exactly what each entry contains: index, name, path, and active status. It also distinguishes itself from get_document_state, which only reports the active document, making the tool's role within the sibling set 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?

The description explicitly states when to use this tool instead of an alternative: 'get_document_state only reports the active document; this is how you discover the others before switching.' This gives the agent a concrete decision rule and names the alternative tool directly.

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 READ-ONLY NATURE IS CLEARLY INDICATED VIA 'RETURNS' AND 'FETCH DATA INLINE', PLUS THE readOnlyHint=true DEPTH IS CONSISTENT. THE readOnlyHint ABOVE ALREADY PROVIDES A HIGH BASELINE. THE MAIN AREA WHERE THE DESCRIPTION ADDS VALUE BEYOND ANNOTATIONS IS THE DETAILED 'INCLUDE_PARAMS' EXAMPLE ('FIND ALL CUBES WITH A TEXTURE TAG') AND THE WARNING THAT THIS IS THE DEFAULT WITH NO FALLBACK RISK. THAT'S A SMALL GAP: THE DESCRIPTION MENTIONS 'TYPE_SPECIFIC FIELDS' BUT DOESN'T ADDRESS WHAT HAPPENS FOR NON-OBJECT KINDS.

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 DENSE AND ATTEMPTS TO CONDENSE INFORMATION, BUT IT PAYS A TAX IN READABILITY WITH EXTENSIVE PARENTHETICALS AND SEMI-COLONS CREATING COMPLEX NESTING. THE 'NOTE:' AT THE END IS A GOOD CHOICE OVER NO SEPARATION FOR TELEGRAPHIC STYLE, BUT THE SEMI-COLON DENSE BLOCKS ARE HARD TO SCAN.

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

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

A HIGHLY EFFECTIVE READ-ONLY LISTING TOOL WITH NO OUTPUT SCHEMA AND NO DOCUMENTATION TO DRIFT. WHAT KEEPS IT FROM A '5' IS THE LACK OF DOCUMENTATION FOR THE 'INCLUDE_PARAMS' RETURN FORMAT AND HOW IT INTERACTS WITH THE 'PARAMS' FIELD IN THE OUTPUT. THE BOOLEAN FLAG VERSUS THE 'PARAMETER' ARRAY MENTIONED IN 'INCLUDE_PARAMS' LEAVES A SMALL GAP IN UNDERSTANDING THE EXACT RETURN SHAPE. THAT SAID, THE 'USE FOR PARAMS' IS AN EXCELLENT TOUCH THAT PRE-EMPTS A LIKELY SOURCE OF CONFUSION.

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 HAS 100% COVERAGE, SO THE PARAMETER DESCRIPTIONS ARE JUST A BONUS. THE REAL VALUE IS THE SEMANTIC COLOR IT ADDS: TURNING 'TYPE_IDS' INTO A MORE USEFUL CONVERSATION BY GIVING THE EXAMPLE '[5159]' FOR CUBES. SIMILARLY, FOR 'TAG_TYPES' — '[5616]' FOR TEXTURE — MAKES THE INTEGERS INSTANTLY ACTIONABLE. THE 'MAX_DEPTH' PARAMETER IS SELF-EXPLANATORY. IT'S HARD TO COMPLAIN ABOUT A SECOND PARAMETER WHEN THE SCHEMA ALREADY HANDLES THE HEAVY LIFTING. AT BEST THIS IS 'EFFICIENT'.

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?

EXCELLENT OPENING: 'ENUMERATES SCENE ENTITIES OF A GIVEN KIND' IS CRISP, VERB-DRIVEN, AND DISTINGUISHES FROM SIBLINGS BY IMPLYING IT'S A READ-ONLY LOOKUP. THE 'RETURNS COMPACT SUMMARIES...' LINE AND CONTEXTUAL 'USE THIS FIRST TO FIND WHAT EXISTS' MAKE THE PURPOSE 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?

EXCELLENT EXPLICIT GUIDANCE: 'USE THIS FIRST TO FIND WHAT EXISTS BEFORE DESCRIBE/SET_PARAMS' AND THE CALL-OUT 'FOR NODE-MATERIAL GRAPHS, USE LIST_GRAPH_NODES' DIRECTLY MANAGE ALTERNATIVE SELECTION. THE 'KIND=SHADER' WALK SHADER CHAINS VERSUS 'LIST_GRAPH_NODES' DISTINCTION IS CRUCIAL AND UNMISSABLE. ALSO CORRECTLY WARNS 'KIND=VIDEO_POST' IS REQUIRED.

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

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

Annotations already declare readOnlyHint=true, so the safe-read nature is known. The description adds meaningful behavioral details beyond that: the filtering behavior specific to the scene-nodes space, and the fact that `supported:false` is returned when the build lacks the maxon framework. These are operational quirks an agent would otherwise not know, so the description adds real value.

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

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

Three sentences with zero fluff. The first sentence states the core purpose and ties it to a specific use case. The second adds a domain-specific nuance about filtering, and the third covers an edge-case response. Every sentence earns its place, and the most critical info (purpose and usage) is front-loaded.

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

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

For a read-only listing tool with one parameter and no output schema, the description is essentially complete: it explains what the tool returns, how to use the results, a special case (scene-nodes filtering), and a failure indicator (`supported:false`). The only thing missing is a precise description of the output format, but that may be implied by the tool's nature and the absence of an output schema. An agent has enough to call this tool correctly.

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

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

The single parameter `node_space` is fully described in the schema (100% coverage) with its alias options, default value, and acceptance of fully-qualified maxon.Id. The description does not add new semantic details about the parameter itself—it only explains how the parameter value affects filtering, which is more of a behavioral note. Since the schema already covers parameter meaning, a baseline 3 is appropriate.

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 'enumerate' and the resource 'node-template asset ids for a node space', and immediately ties it to the `$type` parameter in `apply_graph_description`. It explicitly distinguishes these ids from the `net.maxon.corenode:*` ids reported by `list_graph_nodes`, making it easy for an agent to tell the two tools apart without inspecting schemas.

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

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

The description provides concrete usage context by specifying that the returned ids are what you pass to `apply_graph_description` as `$type`. It also notes that results for the scene-nodes space are filtered to addable templates, giving the agent a condition to watch for. It doesn't explicitly say 'use this when you need X and not when you need Y', but the sibling differentiation and use-case tie make the intended usage clear enough.

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

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

With `readOnlyHint: true` covering the non-mutating nature, the description adds useful behavioral detail beyond the annotations: it returns a flat list and returns `supported:false` when the maxon framework is unavailable or no graph exists. These are exactly the edge-case signals an agent needs to interpret a call result correctly.

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 three sentences with no filler: the first states the action, the second explains the two targeting modes, and the third clarifies the exceptional `supported:false` response. Every sentence carries distinct, 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 read-only listing tool with no output schema, the description is largely complete: it explains purpose, target modes, parameter semantics basics, and an important edge condition. It does not describe item-level contents of the returned node list, but that is a manageable gap given the tool's simple product intent.

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

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

The schema already provides full parameter descriptions, but the tool description adds semantic context by mapping the parameters to real targets: node-based material via `handle` versus active document scene-nodes via `scope:'document'`. This helps an agent choose the right parameter combination even when the schema's `anyOf` definitions are complex.

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

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

The description opens with a concrete action and outcome: 'Walk a node graph and return a flat list of nodes.' It then precisely defines the two target modes: a node-based material via `handle`, or the active document's scene-nodes graph via `scope:'document'`. This clearly distinguishes it from sibling graph tools like `list_xpresso_nodes` and `list_graph_node_assets`.

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

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

The description gives clear context for when to use which targeting mode: materials via `handle` versus the document scene-nodes graph via `scope`. It also explains the `supported:false` condition, but it does not explicitly name sibling alternatives or state when to prefer a sibling tool, so it falls just short of a top score.

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 readOnlyHint=true annotation covering the read-only nature, the description adds value by detailing the exact return structure—name, optional color, and the full flag dictionary. This goes beyond the annotation and clarifies what the agent can expect, though it does not discuss any exceptions like empty documents.

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 with no filler. The first sentence states the core purpose, and the second lists the return contents. Every element is necessary for understanding the tool, making it efficiently structured and front-loaded.

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

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

For a simple enumeration tool with no parameters and a read-only annotation, the description provides sufficient information: what it does and what it returns. It omits edge cases like an empty document, but for a list operation this is a minor gap and the overall context is complete 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 tool has zero parameters, so the schema is trivially complete. The description correctly avoids redundant parameter explanations, which meets the baseline 4 for tools with no parameters.

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

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

The description clearly states the action (enumerate) and resource (every LayerObject in the active document), and specifies the return fields. It distinguishes itself from siblings like get_object_layer by focusing on all layers rather than a single object's layer, though it does not explicitly name alternatives.

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

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

The description implies usage for retrieving all layers, but it provides no explicit guidance on when to use this tool versus related ones like get_object_layer or set_layer_flags. The context is not spelled out, leaving the agent to infer the appropriate scenario.

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 readOnlyHint annotation already covers the safety profile. The description adds behavioural detail about the enumeration (GetFirstMarker + GetNext) and the exact fields returned, plus the index handle. This is more than the annotation provides, though it doesn't discuss performance or edge cases. Since the tool is a simple list, this is sufficient.

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

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

The description is two sentences, front-loaded with the core purpose and output details, then the usage guidance. Every sentence earns its place with no redundancy or fluff. It's 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?

For a tool with no parameters, no output schema, and a read-only annotation, the description provides all necessary context: what it returns, the index handle for further operations, and when to use it. The agent can call this tool correctly without needing additional information.

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

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

The tool has zero parameters, so the schema is empty and schema coverage is 100% by default. The description naturally adds nothing about parameters. As a baseline for no-parameter tools, this is appropriate; the description instead focuses on the output, which is the main semantic content.

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

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

The description clearly states the tool's purpose: to enumerate every timeline marker in the active document, listing specific fields (frame, time_seconds, name, colour, length_frames) and even notes the underlying API. It distinguishes itself from get_document_state by mentioning that get_document_state only reports marker_count, making it evident when this tool is appropriate.

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

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

It explicitly states when to use this tool: 'Use this to verify marker placement' and contrasts it with get_document_state. This gives the agent a clear decision rule for selecting between sibling tools. The mention that the index handle is accepted by set_marker/remove_marker also informs downstream usage.

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

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

Annotations declare readOnlyHint=true, which the description aligns with by using 'Read'. Beyond that, the description discloses a forced scene pass to populate MoData, a meaningful side effect, and the exact return shape including the 'supported:false' condition. This adds substantial behavioral context that annotations do not cover, so it earns a 5.

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

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

Two sentences with no fluff. The first sentence leads with the core action and supported inputs, the second covers return format and failure cases. Every sentence adds value, and the structure is front-loaded.

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

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

For a read-only tool with high schema coverage and no output schema, the description fully covers what an agent needs: what it does, the side effect of forcing a scene pass, the return structure, and when it returns supported:false. No missing information blocks correct invocation.

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

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

Schema coverage is 100%, so the schema already documents all three parameters (handle, max_count, include_matrix) with descriptions. The tool description adds no extra parameter-level meaning, but it does explain the overall data flow and return structure. Per the baseline rule for high coverage, a 3 is appropriate because the description does not need to repeat parameter semantics.

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

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

The description clearly states it reads per-clone transforms from a MoGraph generator, with specific verb 'Read' and resource 'per-clone transforms'. It also gives examples of generators (Cloner/Matrix/Tracer) and distinguishes itself from sibling tools like sample_transform that operate on individual objects, making its purpose unambiguous.

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

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

The description implicitly communicates when to use this tool (to read clone transforms) and lists failure conditions (unsupported builds or non-MoGraph handles). It does not explicitly name alternatives or state when to prefer other tools, but the specialized resource makes the context clear. A small gap remains in not contrasting with siblings like sample_transform, so a 4 is warranted.

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 readOnlyHint annotation already declares the tool is read-only, so the description does not need to repeat that. The description provides some details about the return structure (plugin and plugin_file fields) but does not mention error handling or empty results. This is acceptable for a simple list operation.

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

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

The description is concise and to the point. Two sentences cover the tool's purpose and parameters without unnecessary fluff. The structure is logical, starting with the overall function and then detailing usage.

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 lack of an output schema, the description does a decent job of explaining the return fields. It does not mention potential errors or edge cases, but for a list/filter tool it is reasonably complete. More details on the exact format of the result (e.g., array vs. object) would improve completeness.

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

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

The schema descriptions cover all parameters clearly. The description adds helpful context, such as the plugin_type can be a string alias or raw integer, and gives examples for plugin_pattern. This complements the schema without redundancy.

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 indicates that the tool lists plugins and allows filtering by type and patterns. It mentions the output fields, so the purpose is well understood, though it could be slightly more explicit about returning a list.

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

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

The description explains how to use the tool (pass plugin_type, name_pattern, plugin_pattern) but does not provide guidance on when to choose this over other list tools. It says 'Generalized' which hints at its scope, but lacks explicit 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?

The readOnlyHint=true annotation already communicates the safety profile. The description adds behavioral context on the return shape and the rule that vector tracks become per-component entries, which is useful. It doesn't disclose edge cases such as behavior when no tracks exist, or whether a track is returned once per component in addition to a combined entry. Since annotations cover the main risk, this is acceptable but not exhaustive.

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

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

Two sentences: first states the core action and return contract, second clarifies the vector-track behavior with a concrete example. No fluff, and the most operationally relevant information (return shape, downstream piping, per-component behavior) is front-loaded.

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

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

For a read-only list tool with a single parameter fully documented by the schema, the description fully covers the invocation contract and return shape. One could argue it should state what happens with empty results or whether tracks are returned in any particular order, but these are minor given the tool's simplicity and the annotation already covering the read-only property.

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's handle parameter is fully self-documenting: it describes the parameter as 'Entity whose animation tracks to enumerate' and its type union exhaustively describes accepted entity references. With 100% schema coverage, the description adds little parameter-specific value beyond naming the resolved entity concept, so baseline 3 is appropriate.

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 names the tool's specific purpose: enumerate CTracks on an entity. It lists the exact return fields, explicitly mentions that vector tracks surface per-component, and tells the caller how to use the result with get_keyframes / set_keyframe. This distinguishes it from siblings like list_layers and list_entities.

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

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

The description implies when to use it: when callers need to enumerate animation tracks before working with keyframes. It refers to get_keyframes / set_keyframe as downstream consumers, forming a workflow. However, it does not explicitly say when not to use it or name alternatives for other types of enumeration (e.g., list_layers for layers), which is a light gap.

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

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

Annotations only mark readOnlyHint=true, so the description carries the burden of behavioral disclosure. It adds the return shape (desc_id, name, dtype, value) and the pattern for reusing desc_id, which goes beyond what annotations state. No contradiction with read-only semantics; if anything, the read-only hint is reinforced by the non-mutating language.

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

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

Two sentences, front-loaded with the core action, followed by output shape and integration hint. Every word earns its place.

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

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

For a simple read-only listing tool with a single parameter and no output schema, the description adequately covers purpose, output, and follow-up usage. While it doesn't discuss edge cases (e.g., empty results, performance, or supported target kinds), the complex handle union is fully documented in the schema, so nothing critical is missing.

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

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

Schema coverage is 100% with the handle property described as 'Target to inspect.' The description's phrase 'on a target' adds no new information about the parameter beyond what the schema provides. The description focuses on the output rather than elaborating on the input, so it does not enhance parameter understanding beyond baseline.

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 clear verb ('Enumerate') and resource ('User Data slots on a target'), immediately distinguishing it from siblings like add_user_data and remove_user_data. The output format is also specified, leaving no ambiguity about what the tool does.

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

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

It directs the agent to feed desc_id into related tools (remove_user_data / get_params / set_params), which is a clear usage pointer. However, it does not indicate when to prefer this tool over other listing tools (e.g., list_entities, list_layers) or mention any exclusions.

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

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

The description adds meaningful behavior beyond the readOnlyHint annotation: traversal returns a flat list, ids are stable dotted-index paths with an example, and object handles resolve to the object's first Texpresso tag. It does not contradict the read-only annotation.

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

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

Three dense sentences deliver the purpose, output shape, id semantics, consumers, and input modes with no filler. The most important scoping statement is front-loaded.

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

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

Without an output schema, the description nevertheless tells the agent what the response contains (flat list, per-node id, port summaries) and how those ids feed subsequent operations. For a read-only listing tool with one parameter, this is complete enough to invoke 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?

Even though the schema describes 'handle' and has 100% description coverage, the schema's union type lists ten handle kinds. The description cuts through that ambiguity by stating only tag or object handles are expected and defines the object-handle fallback behavior, adding real semantic value.

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

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

The description names a concrete verb and resource ('Walk an Xpresso tag and return a flat list of its GvNodes') and specifies the result contents (id, port summaries). This clearly distinguishes it from generic siblings like list_graph_nodes by scoping to Xpresso/GvNodeMaster tags.

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

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

It explains when the returned ids are useful, namely for apply_xpresso_graph, set_xpresso_port, remove_xpresso_node, and handle-taking tools, and covers tag-vs-object input. It does not explicitly exclude alternatives such as list_graph_nodes, so an explicit when-not-to-use statement is absent.

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

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

Since annotations are empty, the description carries the full burden of behavioral disclosure. It explicitly states that new-geometry commands return handles to inserted results while in-place commands return the mutated targets. This clarifies the mutation and return-value behavior. It does not discuss undo, error handling, or prerequisites, but the key behaviors are disclosed. No contradiction with annotations (which are absent) exists.

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

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

The description is two sentences: the first states the core action, the second explains return behavior and lists aliases. It is front-loaded and dense with useful information, though the long alias list adds length. Every sentence earns its place, but it could be slightly more streamlined by moving the alias list to a more compact form. Overall efficient 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 complexity (4 params, nested objects, no output schema), the description covers the essential information: what it does, which commands produce new geometry vs in-place, and return values. It does not mention potential errors, required object types beyond handles, or the fact that some commands may be destructive, but these are not critical for an agent to invoke the tool correctly. It is reasonably complete and provides enough context for correct usage.

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 descriptions cover all parameters at 100%, so the baseline is 3. The description adds context about command aliases and the distinction between new-geometry and in-place commands, which helps interpret the 'command' parameter. However, it does not add significant detail about 'mode', 'params', or 'targets' beyond what the schema already states. Value added is modest but not redundant.

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

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

The description states exactly what the tool does: runs a Cinema 4D modeling operation via c4d.utils.SendModelingCommand on one or more target objects. It clearly distinguishes between commands that produce new geometry (returning handles to inserted results) and in-place commands (returning mutated targets). It also lists many aliases, making it unambiguous which operations are covered. This clearly separates it from siblings like call_command or undo.

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

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

The description explains the behavior and gives examples of operations, but it does not explicitly state when to use this tool versus alternatives. There is no mention of when to use modeling_command instead of call_command or list_entities, though the modeling-specific nature is implied. No exclusions or alternative conditions are provided, leaving usage context implicit.

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

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

Without annotations, the description carries the full burden of behavioral disclosure. It discloses the action (reparent, promote, reorder), the constraints on kind and destination, a special case for takes (Main cannot be moved), and the return value (new canonical handle). It does not mention side effects like whether the original node is mutated in place, but 'reparent' implies moving the same node rather than copying. This is substantial behavioral transparency for a mutation tool.

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

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

The description is compact and well-structured. It front-loads the primary action, then scope, then usage constraints, then the return value. Each sentence conveys essential information without redundancy. It is appropriately sized for the tool's complexity, and no extraneous text dilutes the message.

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 five parameters and no output schema, the description provides thorough context: it defines the operation, the valid destination fields, the kind-matching rule, the take-specific behavior, and the return value. It does not cover edge cases like what happens if the parent is the same as the current parent or if the node is already at root, but these are not necessary for typical invocation. The main gap is not explicitly mentioning error conditions, but overall it is sufficiently complete for an agent to call 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?

While the schema already describes each parameter (100% coverage), the description adds meaning beyond schema fields. It explains the mutual exclusivity of destination fields, clarifies that to_root is a boolean and for takes reparents under Main, and highlights the constraint that siblings/parents must share the moved node's kind. These constraints are not evident from the schema alone, so the description enhances parameter understanding.

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

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

The description explicitly states the tool's function: reparent, promote to root, or reorder a node. It specifies the resource types (objects, takes, render_data) and the destination options (parent, before, after, to_root). This clearly distinguishes it from siblings like clone_entity (copy), remove_entity (delete), and set_transform (move in 3D space), making the purpose unambiguous.

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

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

The description gives operational rules: exactly one destination field must be used, siblings/parents must share the moved node's kind, and special take behavior (Main take cannot be moved). However, it does not explicitly state when to choose this tool over alternatives like clone_entity or set_transform. It provides clear context for how to call it but not when to prefer it over related tools.

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

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

With no annotations, the description carries the full burden. It discloses the core behavior (insert and focus) and explicitly notes the current document is not overwritten, which is a key side effect. It doesn't cover all possible side effects (e.g., undo stack), but given the tool's simplicity, this is adequate.

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

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

Two sentences with no filler. The primary action is front-loaded, and the usage context follows immediately. Every word earns its place.

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

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

For a simple creation tool with two optional parameters and no output schema, the description fully covers purpose, behavior, and usage. Nothing an agent needs to call it correctly is missing.

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

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

Schema coverage is 100%, with both 'name' and 'make_active' described in the schema. The description only mentions 'by default switch focus' which mirrors the schema's default for make_active, adding no extra semantic value. Baseline 3 applies.

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

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

The description states a specific action ('Insert a fresh empty BaseDocument'), a clear resource, and the side effect ('switch focus to it'). This distinguishes it from siblings like open_document, list_documents, and set_active_document, making the tool's purpose unambiguous.

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

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

The description gives a concrete use case ('starting a clean scene without overwriting the current one'), which implies when to use the tool. It doesn't explicitly name alternative tools or exclusions, but the context is clear enough for an agent to decide.

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 empty annotations, the description carries the burden. It discloses the core behavior (new document creation) and the make_active parameter's effect on focus. It also mentions the distinction from import_scene's merge behavior. This is adequate, though it doesn't detail error handling or interactions with the current document beyond the implicit new-document creation.

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

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

Two sentences with a parenthetical, no fluff. The main purpose is front-loaded, and the key distinction from import_scene is immediately presented. Efficient 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?

For a simple load operation with only two parameters and no output schema, the description covers the purpose, the parameter behavior, and the critical sibling distinction. It doesn't need to discuss return values. Could mention error conditions or current document state, but those are minor gaps for a straightforward 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 100%, so both parameters are documented. The description adds marginal value by restating the effect of make_active and its default, slightly clarifying how to use it. This aligns with baseline 3 for full schema coverage.

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 it loads a Cinema 4D scene file as a new document, a specific verb and resource. It also explicitly differentiates from import_scene, making the purpose unambiguous for an agent.

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 specifically contrasts with import_scene, explaining that this opens a file as its own document rather than merging. This gives clear when-to-use guidance for the most relevant sibling, though it doesn't enumerate all potential alternatives like new_document.

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 declare readOnlyHint=true, which the description aligns with. The description adds no additional context such as possible failure modes, timeouts, or what a successful response looks like. Given the simple nature of a ping, the description is acceptable but 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?

A single, front-loaded sentence with no wasted words. The core action and target are stated immediately.

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

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

For a simple connectivity check with no parameters and no output schema, the description is sufficient. It could mention the return value (e.g., success/failure), but this is lightly implied by 'check connectivity' and is not a major gap for such a basic tool.

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

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

The tool has zero parameters, and schema coverage is 100% (empty properties). The description correctly adds no parameter information because none exist. This meets the baseline for a parameter-less 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 a specific verb ('Check') and resource ('connectivity to the Cinema 4D bridge plugin'). It distinguishes from sibling tools by indicating this is a connectivity test rather than a document or scene operation.

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. There is no mention of prerequisites, typical usage scenarios (e.g., before other commands), or cases where it should be avoided. Usage is only implied.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure—and it excels. It discloses that the active editor view is temporarily switched to Constant Shading (Lines), that the render is built freestanding and never inserted, and that BaseDraw/camera/time/take state is restored in finally. It also states it returns a base64 PNG inline. This is exemplary transparency about side effects and restoration 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 dense but well-structured. It opens with the core purpose ('Quick agent-friendly verification render'), then details the renderer and state restoration, followed by output format, and finally the view/camera/save_path options. Every sentence adds value, though it is slightly longer than necessary for the amount of detail (e.g., the try/finally detail could be implied). No fluff.

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

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

Given the tool's complexity (7 parameters, no required, no output schema, no annotations), the description is remarkably complete. It covers the return format (base64 PNG), the side effects (state restoration), the mutual exclusivity of view/camera, and the optional disk write. An agent has everything needed to invoke it correctly without additional context.

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

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

Although schema coverage is 100% (all parameters documented), the description adds meaningful semantic context beyond the schema. It explains that 'view' presets place a temp camera looking at scene bounds and that it is removed in finally, that 'camera' is mutually exclusive with a non-'current' view, and that save_path still returns the base64 PNG inline. This goes beyond the raw schema definitions and enriches agent understanding.

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 does a 'quick agent-friendly verification render' using the Viewport renderer with Constant Shading (Lines). It explicitly distinguishes itself from a full render (independent of active RenderData, freestanding) and even contrasts with siblings like 'render' by being a lightweight preview. The verb 'render' with the resource 'preview' is precise and the styling detail (sketch-style and fast) further clarifies 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 establishes clear context: it is for quick verification, not final output, and it is independent of the active RenderData. It explains the view/camera options and the save_path for disk output. However, it does not explicitly state when NOT to use it or name a specific alternative (like 'render' for final renders). The implied usage is strong but lacks explicit exclusions.

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

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

The destructiveHint annotation already flags the action as destructive, and the description adds the useful detail that the deletion is wrapped in an undo step, implying the action is reversible. That goes beyond the basic annotation but does not explain dependent objects or failure modes such as deleting an already-deleted entity.

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

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

The description is a single sentence with no waste and places the main verb first. This is appropriately concise for a simple tool with one parameter.

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

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

The schema covers the parameter and the annotation covers the operation's destructive nature, but the concept of a 'resolved entity' is not explained. The description also does not mention what happens if an entity is missing or whether the undo step is user-facing, leaving some ambiguity for an agent in edge cases.

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

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

Schema description coverage is 100%, with the handle parameter documented as 'Entity to delete.' The description only reiterates that a resolved entity is deleted, adding little beyond the already-complete schema documentation and leaving the resolved semantics undefined.

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 ('Delete') and the target ('the resolved entity'), so the core purpose is unambiguous. It doesn't explicitly distinguish itself from sibling removal tools like remove_graph_node or remove_marker, but the generic 'entity' wording and the tool name make the intent clear enough for a 4.

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 other removal tools in the sibling list. The description also does not clarify what 'resolved' means or when an agent should use a more specific removal tool (e.g., remove_graph_node) instead.

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 declare destructiveHint=true, and the description's 'Delete' is consistent. It adds the constraint that the id must be a stable maxon.Id, but does not disclose behavior such as whether connected edges are also removed or how errors are handled.

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

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

Two concise sentences, front-loaded with the action, followed by a necessary id requirement. No redundant words 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?

For a destructive node deletion, the description covers the core action and the critical id requirement. The schema handles scope/handle/node_space, and the destructiveHint annotation covers the safety profile. Could mention what happens to connected nodes, but that's not essential for correct invocation.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning to node_id by clarifying it's a stable maxon.Id and referencing list_graph_nodes/apply_graph_description, which is more specific than the schema's 'The id of the node to remove.'

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

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

States a specific verb 'Delete', a specific resource 'node by id', and a specific context 'node-material graph'. This clearly distinguishes it from sibling removal tools like remove_xpresso_node and remove_entity.

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

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

Provides an explicit precondition: the id must match the node's stable maxon.Id and points to list_graph_nodes or apply_graph_description as references. This tells the agent how to obtain a valid id, though it doesn't explicitly name alternatives or exclusion conditions.

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

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

Annotations already mark this as destructive (destructiveHint: true). The description adds valuable context beyond that: how identical markers are disambiguated ('error if several markers match'), that `all:true` ignores selectors, and the exact return shape `{removed: N}`. It doesn't mention reversibility or side effects, but destructiveHint covers the main risk.

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

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

Two sentences carry full operational meaning with zero filler. The primary action and modes are front-loaded, followed by the disambiguation rules and return value. Every clause earns its place.

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

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

For a destructive tool with no output schema, it covers the action, selector rules, error conditions, and return value. A minor gap is that it doesn't explicitly state what happens when no selector or `all` is given, leaving that edge case to the agent's inference. Still, the coverage is strong and sufficient for correct invocation.

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

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

Schema descriptions are 100% per-property, giving baseline 3. The description goes further by adding the relationship between parameters: exactly one of `index`, `frame`, or `name` for a single target, and `all:true` overriding the selectors. It also clarifies error semantics for ambiguous matches, which is not present in the schema.

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

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

The description opens with 'Delete one timeline marker, or all of them,' which names a specific verb and resource and explicitly distinguishes the two deletion modes. It is clearly distinct from siblings like create_marker, list_markers, and set_marker, so an agent can select it unambiguously.

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

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

Provides clear when-to-use guidance for each parameter path: pass `all:true` to clear everything, or choose exactly one of `index`, `frame`, or `name` for a single target. It also warns that `frame` and `name` error on ambiguity, and points to `list_markers` for getting the `index`, which is practical routing information.

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

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

The destructiveHint annotation already signals the operation is destructive. The description adds value by clarifying that deletion targets a specific User Data slot and that the operation is undoable, which is useful behavioral context beyond the raw annotation.

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

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

One sentence with no filler. It front-loads the action and resource, then packs the ordering method and undo behavior into a compact, easily parsed 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 simple two-parameter schema, the destructiveHint annotation, and the absence of an output schema, this description tells an agent everything needed to call the tool correctly: what is deleted, how to identify it, where to get the identifier, and what safety net exists.

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 covers both parameters fully: handle is 'Target' and desc_id is 'DescID path — list of [id, dtype, creator?] levels.' The description adds a little context by pointing to list_user_data/add_user_data as the source of a valid path, but it does not carry the parameter-documentation burden.

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 ('Delete'), a specific resource ('User Data slot'), and the exact addressing mechanism ('DescID path'). It clearly distinguishes this tool from siblings like list_user_data and add_user_data by focusing on deletion.

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 practical guidance by stating the DescID path is exactly what list_user_data or add_user_data returns, which tells the agent how to obtain valid input. It also mentions the operation is wrapped in undo, but it does not explicitly discuss when not to use this tool or compare it to 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?

With destructiveHint=true already in annotations, the destructive nature is covered. The description adds genuinely useful behavior beyond the annotation: it reveals that incoming and outgoing connections are severed automatically, which tells the agent it need not manually clean up edges and warns of a cascading side effect. No contradiction with annotations.

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

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

Three tightly-packed sentences with zero filler: the action, the handle precondition plus discovery path, and the side-effect behavior. The most decision-relevant facts (what it does, what handle to pass) are front-loaded.

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

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

For a single-parameter destructive tool with no output schema and destructiveHint covered by annotations, nothing is missing. The description states the operation, the required handle form, how to find the handle, and the automatic disconnection behavior — an agent has everything needed to invoke it correctly without opening the schema.

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 100% and the schema describes handle as 'gv_node handle for the node to remove', but the schema's anyOf union lists many handle kinds (object, material, gv_node, plugin_options, etc.), which could confuse an agent. The description adds decisive value by restricting the valid handle to a GvNode kind and by explaining how to obtain it (via list_xpresso_nodes), cutting through the type 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 opens with a precise verb+resource pair ('Delete a GvNode from an Xpresso graph') and immediately scopes the tool to Xpresso graphs, which distinguishes it from the sibling remove_graph_node and remove_entity. The target type (GvNode) and the graph flavor are both unambiguous.

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

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

The description gives a clear precondition — the handle must be a gv_node handle — and routes the agent to list_xpresso_nodes for discovering the path id, which is actionable workflow guidance. It doesn't explicitly name exclusions or alternatives beyond the Xpresso-graph scope implied by the name and description, so it stops just short of a fully explicit when-not-to-use statement.

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?

Without annotations, the description carries the behavioral disclosure burden and provides important runtime context: calls time out after 180 seconds, heavier renders continue running, and the call returns a timeout. It does not describe success-return details, but the key asynchronous/timeout behavior is disclosed.

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: it states the action first, then the relevant workflow, then the timeout caveat. Every sentence adds useful guidance and nothing is redundant with the schema.

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

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

For a small tool with one optional parameter, the description covers the main escape-hatch behavior, the dependency on active RenderData settings, and the timeout policy. It does not describe the exact return shape, but for a render call this is a minor gap given the clearly documented tool purpose and 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?

There is only one parameter, output_path, and the schema already describes it fully as optional, absolute, and defaulting to a temp file. Since schema coverage is 100%, the baseline is 3, and the description adds nothing further about the parameter.

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

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

The description clearly states the operation: render the active Cinema 4D document using the currently active render data settings. It specifies a concrete verb, resource, and the settings scope, which helps distinguish a full render from sibling functions like preview_render.

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 explicitly routes the agent to adjust RenderData first via create_render_data or set_params if resolution, renderer, frame range, etc. need changing. It does not explicitly discuss when the sibling preview_render should be used, so it lacks a full when/when-not contrast.

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 declare destructiveHint=true, so the destructive nature is known. The description goes well beyond: it specifies exactly what gets removed (objects, materials, non-active render data, non-main takes), the undo buffer flush, the full-document swap without prefix, and the performance rationale. This is substantial behavioral context that annotations alone don't provide. The only minor gap is that it doesn't mention return value or errors, but with destructiveHint true and no output schema that's acceptable.

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

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

Three sentences, each dense with information, front-loaded with the core behavior and conditional logic, then a performance note. No fluff.

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

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

Given it's a destructive tool with two branches (prefix and no-prefix), the description fully specifies what gets removed, the undo flush, the keep_active_rd default, and why it beats remove_entity. The output schema is absent but not needed for a void-ish operation. Complete.

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

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

Schema coverage is 100% (both params documented), but the description adds crucial semantics: the prefix param's behavior is explained ('removes only objects / materials / non-active render data / non-main takes whose name starts with the prefix'), and the interaction with keep_active_rd (prefix-mode only, default true) is stated. It explains the conditional behavior of prefix vs no prefix in plain language. Adds clear meaning beyond 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?

Description opens with 'Clear scene state in one RPC' — a specific verb and resource. It then distinguishes two modes (prefix vs full reset) with concrete effects: removing objects/materials/render data/takes matching a prefix plus flushing undo, or swapping the active document for a fresh BaseDocument. Clearly distinct from siblings like remove_entity and undo.

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

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

Explicitly states when to use each mode — 'with prefix' for targeted cleanup, 'without prefix' for full reset — and names the alternative, remove_entity, with a concrete comparison: 'Much faster than chained remove_entity calls when cleanup involves animated objects.' Gives the exact context (test cleanup) where this tool is appropriate.

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

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

Annotations are empty, so the description carries full responsibility for disclosing side effects. It mentions 'evaluate the scene' but does not mention that the playhead may move or that restore_time controls this, nor does it disclose performance implications or that it is read-only. This is a significant gap for a tool with no annotation coverage.

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

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

The description is two concise sentences with no filler. It front-loads the primary purpose and adds a relevant usage note, all without extraneous 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?

With 6 parameters, no output schema, and no annotations, the description needs to explain more about behavior (like playhead restoration), output format, and handle resolution. It only covers the basic function, leaving users to infer many operational details, making it incomplete for correct invocation.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds nothing about parameters beyond what the schema already documents (e.g., fps, space, format). It does not clarify or expand on the parameter semantics, so it stays at baseline.

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 (evaluate scene at each frame) and the outcome (return transform), with a specific verb and resource. However, it does not explicitly differentiate from sibling tools like set_transform or get_params, so it loses a point for lacking sibling distinction.

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

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

It provides a use case ('useful to verify alembic/constraint/xpresso-driven animation') but does not explicitly state when not to use it or name alternative tools. The usage context is implied rather than explicit, so it falls short of a 4.

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 empty annotations, the description carries the full behavioral disclosure burden. It adds meaningful details: the path must be absolute and the parent directory must exist, and it explains the Save-As-Copy behaviour (internal name/path unchanged). It doesn't mention overwrite semantics or return values, but it covers the key behavioral traits that affect how an agent calls 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 compact and well-structured: it opens with the core action, then the key path requirement, then the format list, and finally the copy nuance. Every sentence carries necessary information without any padding 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 save operation with three parameters and no output schema, the description covers the essential context: what it does, key format choices, a behavioral fork (copy vs. normal), and a non-obvious path constraint. It lacks explicit overwrite behavior, but that is commonly implied for save operations and the description remains sufficiently complete for an agent 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 coverage is 100% (all parameters have schema descriptions), so the baseline is 3. The description enriches the semantics by clarifying the copy parameter (with `copy:true` the document's internal name/path is left unchanged) and by spelling out the path requirement (absolute, parent dir exists) that the schema only mentions as 'Absolute output path.' This adds value 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 clearly states the verb (save) and resource (the active document), and specifies the action's scope: saving to disk. It also lists supported formats and the distinct copy behavior, which distinguishes it from sibling tools like open_document or new_document.

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

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

The description provides clear context for when to use the tool: saving the active document to disk, with explicit preconditions (absolute path, parent directory must exist). It does not explicitly name alternatives, but the sibling list and the nature of the operation make it obvious this is the save operation, not open/import. A bit more explicit 'when to use vs other tools' would make it a 5.

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