fxhoudinimcp

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

No annotations are provided, so the description carries the full burden. It does not disclose whether a new Material SOP node is created, what happens if the target already has a material, whether the operation is reversible, or any permission/error behavior. For a scene-mutating tool this is a substantial gap.

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

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

The one-line purpose is front-loaded and the Args block is compact with no filler. It is appropriately sized, though the param lines are so terse they add little value.

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 mutating tool with no annotations, no output schema, and effectively undocumented parameters needs to explain side effects, prerequisites, and failure modes. The description stops at what it does, leaving an agent unable to predict the result of the call.

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

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

Schema description coverage is 0%, so the description must compensate, and it barely does: 'Target geometry node path' and 'Material to assign' essentially restate the parameter names. No path format (absolute vs relative, node-type expectations) or validation semantics are given.

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

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

Names a specific verb and resource (assign a material to a geometry node) and distinguishes itself from siblings like create_material or list_materials. The phrase 'via a Material SOP' adds a hint of mechanism but is ambiguous about whether it creates a new node or reuses an existing one.

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

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

No when-to-use guidance, no prerequisites (e.g., does the material need to exist first?), and no routing to alternatives such as get_usd_bound_material for reading an existing assignment. The agent is left to infer context entirely.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses atomic all-or-nothing execution, validation before creation, did-you-mean errors, cooked evidence, expression preservation, locked parm refusal, callback replay, display fallback, and simulation_cache 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 purpose and atomic constraint are front-loaded, and later paragraphs progress from validation to node spec details to edge cases. It is long, but most clauses are justified for this complex tool, though some dense edge-case clauses could be tightened.

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

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

Given a complex 4-parameter mutation tool with no annotations, no output schema, and 0% schema description coverage, the description covers invocation, validation, error behavior, layout, and result evidence. It is complete enough 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 0% and the top-level schema has no parameter descriptions, yet the description explains parent_path creation/removal, node spec keys in detail, dry_run validation, and layout behavior. It adds essential meaning beyond the raw schema.

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

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

States a specific verb and resource: build a whole node network in one atomic call. It explicitly says this is preferred for 3+ nodes and differentiates from node-by-node calls, so an agent can distinguish it from siblings like create_node or build_sop_chain.

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

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

Explicitly gives when to use it: anything of 3+ nodes, and dry_run=True for unfamiliar node types. It also names the alternative node-by-node approach and explains the no children key workaround of building a subnet then calling build_network again.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses that nodes are created in order, automatically connected, and built in one round-trip, but it omits mutation permissions, failure/atomicity behavior, and whether existing nodes or parent networks are affected.

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

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

Front-loads the purpose, follows with preferred usage, then documents the step format and example before the Args block. 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?

With no annotations and no output schema, the description still covers usage and parameter semantics well. It does not describe return values or failure behavior, which is a gap, but it is largely 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 coverage is 0%, so the description must compensate. It defines the step dict keys (type, optional name, optional params) and provides a concrete example, adding substantial meaning beyond the sparse schema; parent_path is described only minimally.

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

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

States a specific verb and resource: building a sequential chain of SOP nodes wired together in a single call. It also distinguishes itself from individual create_node calls, so the agent can select it correctly.

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 says it is PREFERRED over individual create_node calls for linear SOP chains, naming both the alternative and the condition that selects it. This is exactly the routing guidance an agent needs.

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

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

With no annotations, the description carries the full behavioral burden and falls short: it does not say whether cancellation is destructive/irreversible, whether in-progress work items are discarded, what happens if nothing is cooking, or whether it can be resumed. Only the bare operation is stated.

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 core sentence is short and front-loaded. The trailing 'Args:' block adds some noise, particularly the 'ctx: MCP context' entry, which is not even a declared schema 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 tool is simple (one required param, no output schema, no nested objects), so a short description is reasonable. However, with no annotations and no output schema, the agent still lacks information about side effects, post-cancel state, and error behavior.

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

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

Schema description coverage is 0%, so the description must compensate; it does partially by clarifying that node_path accepts either a TOP node or a TOPnet path, which is more than the schema's bare 'Node Path' string. It still omits format details such as path syntax, relative vs absolute, or what an invalid path yields.

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 clear verb+resource: 'Cancel active cooking on a TOP network,' which is specific and actionable. It does not, however, distinguish this from the sibling pause_top_cook, leaving the agent to infer the difference between cancelling and pausing a cook.

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

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

There is no when-to-use guidance, no stated prerequisites (e.g. that a cook must be active), and no mention of alternatives such as pause_top_cook or cook_top_node. The agent gets no routing help for choosing between the closely related sibling 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 and mostly delivers: it discloses the write-to-disk side effect ('image is written to disk only; open output_path with your file reader'), the non-animated framing of node_path, and the fields the reply returns (visible_bounds, node_bounds, node_in_view in network space). It omits failure/error behavior and any dependency (e.g. needing a live Houdini session), so it falls short of full transparency.

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

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

Front-loaded with the core purpose, then engineering details, then the alternative-tool guidance, with an Args block that adds semantics rather than restating names. It is a touch long for a two-parameter tool but every sentence carries information.

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

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

For a two-parameter screenshot tool with no output schema and no annotations, the description covers purpose, side effects, output location, the frames the reply reports, and when not to use it. Remaining gaps (error cases, connection prerequisites) are minor and not required to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: output_path is documented with its default ('a new PNG in the temp dir') and node_path with its effect ('Node path to frame before capture'). Both parameters gain meaning beyond the bare anyOf/null schema, though format details (e.g. accepted node path syntax) are absent.

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

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

States a specific verb and resource: 'Capture a screenshot of the network editor,' and the node_path framing behavior narrows the scope further. It does not, however, distinguish itself from the closely related sibling capture_screenshot or render_viewport, which an agent could plausibly reach for instead.

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

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

Gives explicit routing guidance: 'Prefer get_node_info or list_children for inspecting node connections unless visual confirmation of wiring is genuinely needed.' This names concrete alternatives and the condition that selects them. It stops short of 5 because it never addresses the nearest siblings (capture_screenshot / render_viewport) that overlap in purpose.

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

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

With no annotations, the description carries the full burden and does well: it discloses that the image is written to disk only and must be opened via output_path, that settle_seconds does not block Houdini, and that the value is capped at 120. It stops short of covering failure modes (e.g., invalid pane_name) or permission/headless constraints, so it is strong 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?

Front-loads the purpose, then the disk-write behavior, then the preference rule, then per-argument notes. Every sentence earns its place and there is no padding 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?

For a 3-param, zero-annotation, no-output-schema tool, the description covers purpose, routing, defaults, and the settling/cap behavior, and effectively explains the return side by noting the image goes to disk. It could add a sentence on error conditions (bad pane_name, unwritable path) but is complete enough 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 description coverage is 0%, so the description must compensate, and it documents all three parameters: output_path's default (a new PNG in the temp dir), pane_name's meaning, and settle_seconds' purpose, non-blocking behavior, and 120 cap. This is meaning well beyond the bare schema types and defaults.

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

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

States a specific verb and resource ("Capture a screenshot of the viewport or a specific pane tab") and explicitly names the sibling tools (get_geometry_info, get_node_info, get_scene_summary) it should be preferred over. An agent can tell what this does and how it differs from the info-gathering tools without opening a 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?

Gives an explicit when-not-to-use rule ("Prefer get_geometry_info, get_node_info or get_scene_summary unless visual confirmation is genuinely needed"), naming the alternatives and the condition that selects them. Nothing is left to inference.

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

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

With no annotations, the description carries the full burden and does well: it explains that unversioned names map to the preferred version (as create_node does) and that values not carried over are reported in parms_dropped/parms_reset. It stops short of stating permission/auth requirements or confirming reversibility, so a full 5 is not warranted.

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?

Behavior and rationale are front-loaded before the Args list, and the structure is scannable. The prose paragraph is slightly verbose and partially restates the parameter list, but every sentence conveys real meaning without filler.

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

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

For a mutation tool with no annotations and no output schema, the description is largely self-sufficient, even hinting at return fields (parms_dropped/parms_reset). It could be more complete by addressing failure/error conditions or permission needs, but nothing essential to correct invocation 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 0%, so the description must compensate and it does: it documents node_path, new_type (clarifying it is in the node's own category and how unversioned names resolve), keep_name, keep_parms, and keep_network_contents, including the non-obvious behavior that keep_network_contents=False resets an asset to its definition's contents even when already of new_type.

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

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

States a specific verb and resource ('Change a node's type in place') and immediately enumerates what is preserved (wires, name, position, flags, parameter values, network contents). This clearly distinguishes it from siblings like create_node, delete_node, and copy_node, which do not mutate an existing node's type.

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

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

Provides concrete when-to-use scenarios: moving an HDA instance to an installed newer version without losing edits, and swapping a placeholder for the real node. It does not name explicit alternative tools or state when-not-to-use, but the use contexts are clear enough for correct 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 behavioral burden. It does usefully state what gets destroyed (on-disk cached files for a specific node) and the frame_range scoping limit, but it omits irreversibility, whether files in use by a running sim are affected, and permission/confirmation requirements — notable gaps for a destructive delete.

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 purpose is front-loaded and compact, but the boilerplate 'Args:' block weakens it — 'ctx: MCP context' documents a non-parameter and wastes a line, and the param notes are terse. Acceptable but not tight.

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 mutation tool with no annotations, no output schema, and 0% schema coverage, the description is too thin. It should warn about permanence, describe what a caller gets back, and specify when to use it versus write_cache/list_caches. As-is, an agent lacks what it needs to invoke this safely.

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

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

Schema description coverage is 0%, so the description must compensate. It adds real meaning for node_path ('Path to the cache node') and clarifies frame_range as '[start, end] frame range to limit deletion', which is more than the bare schema. However, the 'ctx' entry is not an actual schema parameter and the frame_range null/default behavior is unaddressed.

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

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

States a specific verb + resource: 'Delete cached files on disk for a cache node.' This clearly separates it from the read-oriented siblings list_caches/get_cache_status and from write_cache. It does not, however, explicitly name an alternative, so it falls just short of full sibling differentiation.

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

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

No when-to-use, when-not-to-use, or prerequisite guidance is given. It never says how clear_cache relates to write_cache (e.g. to invalidate a stale cache before rewriting), nor when frame_range should be omitted versus set. Usage must be inferred entirely from the one-line purpose.

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

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

No annotations are provided, so the description carries the full burden. It does not say whether snapshots persist, whether 'take' overwrites an existing snapshot of the same name, where snapshots are stored, or what a comparison returns. For a dual-mode state tool with zero annotation coverage this is a significant gap.

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

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

Very short and front-loaded, with the core purpose in the first sentence. The raw 'Args:' block is minimally structured but not wasteful; nothing here pads the description.

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

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

With no annotations, no output schema, and an underspecified dual-mode contract, the description is not complete enough. An agent cannot tell what compare yields or how take interacts with an existing snapshot name, which are the two things that determine correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It does add the meaningful part — that action accepts 'take' or 'compare' (the schema only declares a string with a default and no enum) — but 'snapshot_name: Snapshot name' is pure tautology and leaves naming/uniqueness semantics unexplained.

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

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

The description names a specific verb pair and resource: take or compare scene state snapshots. That is clear enough to distinguish it from unrelated siblings like get_scene_info, but it does not differentiate it from the other comparison/snapshot-adjacent tools in a large sibling list, and 'scene state' is left undefined.

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 take versus compare, no prerequisites, and no mention of alternatives. The action values 'take'/'compare' are the only usage signal, and they are presented as a bare parameter listing rather than a when-to-use rule.

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

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

With no annotations, the description carries the full burden and does disclose meaningful behavior: both fields are 'sampled on a grid over field's box', and 'the first band's field_total is what is inside' hints at the result structure. It still omits cost, whether it cooks upstream geometry, and permissions/side-effects, so it is adequate but incomplete.

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

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

Purpose is front-loaded in one line, followed by the example and then the argument list. The example is a bit wordy but earns its place by disambiguating a niche concept; 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?

For a five-parameter compute tool with no annotations, no output schema, and 0% schema coverage, the description covers every parameter plus an illustrative result ('field_total'). The remaining gap is the overall shape of the return value and performance characteristics, which are minor for this tool class.

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

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

Schema coverage is 0%, so the description must compensate, and it largely does: all five parameters are annotated in the Args block, including the dual meaning of bands ('Band count, or a list of band edges') and against_node's conditional role ('when not node_path'). This meaningfully exceeds the bare schema anyOf types, though edge-ordering semantics could be spelled out further.

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

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

The opening line states a specific operation – binning one field's totals by the bands of another field – and the density-vs-collider example makes the abstract verb concrete. It's clearly distinguishable from neighbors like sample_volume and get_volume_info, though it never names them, so differentiation is implicit rather than explicit.

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

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

The worked example ('how much density is inside the collider') shows one scenario where this tool applies, which gives implied usage. However it never states when not to use it, nor points to alternatives like sample_volume for single-point queries, leaving the agent to infer the boundary.

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. The phrase "from now on" usefully discloses that this is a persistent state change affecting subsequent calls, but nothing is said about failure modes (invalid/absent port), whether existing sessions are dropped, or auth needs.

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 purpose sentence is front-loaded and terse, and the pointer to get_houdini_connection_status is efficiently placed. The Args block is slightly redundant with schema but short, so little is wasted.

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 single-parameter connection tool with no output schema this is nearly adequate — it says what it does and how to find a port. It still omits what the agent should expect afterward and error/edge behavior, leaving a gap for a state-changing connection tool with no annotations.

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

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

Schema description coverage is 0%, so the description must compensate. The Args line clarifies that the port identifies a specific Houdini session and points to get_houdini_connection_status as the way to obtain it, which adds real meaning, though it does not state valid ranges or format.

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

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

The description states a clear action on a specific resource — connect to ("talk to") the Houdini instance on a given port — and the phrase "from now on" signals this changes the active session. It does not name sibling tools start_houdini/stop_houdini, but the purpose is readily distinguishable from them.

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

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

"get_houdini_connection_status lists the sessions and their ports" implicitly tells the agent to discover a port there before calling. However, there is no explicit when-to-use versus when-not, no description of relationship to start_houdini, and no prerequisites stated beyond that hint.

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

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

With no annotations the description carries full burden. It usefully discloses a non-obvious behavioral subtlety (SubnetIndirectInput is not a node, has no path, and dest_path must live inside the subnet), but omits what happens on invalid paths, whether connecting replaces an existing input connection, and permission/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?

Front-loads the purpose, then the special subnet case, then an Args block. Well organized and mostly free of filler, though the indirection paragraph is slightly verbose for the value it adds.

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

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

For a 6-parameter connection tool with no annotations and no output schema, the definition covers the tricky subnet/connector semantics and every parameter. It is nearly complete, missing only failure/return behavior and coexistence with the batch 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 coverage is 0%, so the description must compensate, and it largely does: all six parameters are explained, including precedence ('input_name ... wins over input_index'), defaults implied for indices, and a concrete example ('base_color' on a VOP shader). Only minor gaps remain, e.g. index base/range.

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

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

States a specific verb+resource: 'Connect two nodes together'. The singular framing implicitly contrasts with the sibling connect_nodes_batch, but it never names that alternative or otherwise explicitly differentiates itself from related tools like disconnect_node or reorder_inputs.

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 a clear scenario for one mode: wiring a subnet's own input connector into a node inside that subnet (indirect_input). However it gives no guidance on when to prefer this tool over connect_nodes_batch, nor any preconditions such as valid paths or cycle avoidance.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose meaningful wiring semantics ('input_name ... wins over input_index' and indirect_input meaning), but says nothing about permissions, whether the operation is atomic, what happens if one connection in the batch fails, or what is returned. These are significant gaps 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?

Front-loaded one-line summary followed by a compact per-key breakdown. Every line carries information; there is no filler, though the nested parenthetical for indirect_input is a little dense.

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?

Parameter semantics are complete despite the empty schema, which is the hardest part of this tool. However, with no annotations and no output schema, the description still omits error/partial-failure behavior, return value, and usage routing, leaving the definition only minimally complete for a batch mutation tool.

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

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

Schema description coverage is 0% and the schema is an untyped array of objects, so the description does all the work. It enumerates every key (source_path, dest_path, output_index, input_index, input_name, indirect_input), gives defaults, and explains precedence and the subnet/indirect connector case in detail.

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

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

States a specific verb+resource ('Connect ... node pairs') and immediately scopes it with 'multiple ... in a single call', which distinguishes it from the sibling connect_nodes. It could be stronger only by naming connect_nodes explicitly as the single-pair alternative.

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

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

There is no guidance on when to choose this batch tool over connect_nodes, no prerequisites, and no note on when a batch call is preferred (e.g., chains, large graphs). The agent must infer the intended usage entirely from the tool name.

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

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

With no annotations, the description carries the full burden and does so richly: it discloses ordering semantics (frames cooked in order, solvers accumulate), the meaning of the returned `static` flag, the >25-frame row sampling rule (`frames_shown`, totals/slowest_frame still cover all frames), error/warning surfacing, and the side effect that the frame is left where the cook ended.

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

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

Front-loaded with the core purpose before the feature detail and args; sentences are dense but almost all earn their place. Slightly verbose in places (the multi-clause sentence about solvers/DOP/animated chains), but no filler paragraphs.

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

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

No output schema and no annotations exist, so the description must explain return content itself, and it does: per-frame cook time, errors, counts, bounding box, attribute aggregates, sampled-row behavior past 25 frames, and slowest_frame. An agent has everything needed to call and interpret this.

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

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

Schema description coverage is 0%, so the description must compensate, and it documents all six params: node_path, start/end defaults from the playbar, step with a hard warning to keep it at 1.0 for solvers, attribs aggregation modes (min/max/mean/sum), and volumes reporting detail.

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

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

States a specific verb and resource ('cook a node frame by frame') plus the measured output ('report what changed on each frame'). It explicitly distinguishes itself from siblings set_frame and step_simulation by name, so an agent can route correctly without opening schemas.

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

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

Directly names the alternatives it replaces: 'Prefer this over set_frame in a loop, and over stepping by hand: a 100-frame check is one call rather than 100.' It also gives when-to-use context ('how you advance a sequential solver and how you prove a simulation is doing something').

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

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

With no annotations, the description carries the full burden, and it does disclose that block controls whether the call waits for completion and generate_only skips actual cooking. That is genuine behavioral context beyond the bare schema. It still omits failure behavior, duration expectations, and side effects on existing work items, which matters for an execution 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 lead sentence is front-loaded and the parameter list is compact with no filler prose. The 'ctx: MCP context' line is wasted space for an agent caller, keeping it from a 5.

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

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

For a three-parameter execution tool with no annotations and no output schema, the description covers the mechanics but says nothing about return values, error handling, or what a completed cook yields. The block flag implies a completion signal, but the agent is left to infer the rest.

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

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

Schema description coverage is 0%, so the description must compensate, and it does name each parameter with meaning: wait-for-completion for block and generate-without-cooking for generate_only. It does not give format or path syntax for node_path, and 'ctx: MCP context' is not a real caller-facing parameter, so the compensation is only partial.

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

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

States a specific verb (cook) and resource (TOP node) and clarifies the effect: executing the node's work items. It is clearly distinguishable from read-only PDG siblings like get_pdg_graph or get_work_item_states. However, it does not explicitly differentiate itself from the other cook-related siblings such as cook_frame_range or generate_static_items.

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

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

There is no when-to-use or when-not-to-use guidance. Nothing routes the agent between this and cook_frame_range, generate_static_items, or the cancel/pause siblings, nor does it state prerequisites (e.g., that a TOP network must exist or be schedulable).

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

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

No annotations are provided, so the description carries the full burden. It discloses useful behavioral details about placement (right offset in same network, original position in different network, offset overrides both) and notes that 'position' appears in the reply. However, it omits mutation semantics like how the copy's name is resolved when new_name is null, whether the copy inherits connections, and whether this requires the node to be uncooked. Partial transparency only.

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

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

Front-loaded with the core action, then a focused paragraph on placement behavior, followed by a standard Args block. Slightly redundant to list args whose names are already in the schema and whose meaning is partly repeated, but otherwise efficient.

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

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

A mutation tool with no annotations, no output schema, and 0% schema description coverage. The description fills the biggest gap (placement behavior) but does not cover error cases, naming collisions, or permission requirements, so the agent still lacks full context to call it reliably.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning for offset ([dx, dy] from original's position) and confirms dest_parent is for a different network, but leaves new_name's uniqueness behavior and node_path's expected format (e.g., '/obj/geo1/box1') unspecified.

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

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

States a specific verb (Copy) and resource (node) with the key modifier 'optionally into a different parent network', distinguishing it from create_node, move_node, and rename_node.

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

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

Implicitly defines usage through the description of positional behavior in same vs. different networks, but never explicitly states when to prefer copy_node over create_node or when a copy is appropriate. No exclusions or alternatives named.

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

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

No annotations are provided, so the description carries the full behavioral burden and largely does not. It never says what the call returns (presumably a node path), what happens if chop_type is invalid or the name collides, whether the node cooks on creation, or whether it requires an active/connected Houdini session. Only the node-type verification hint adds behavioral 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?

Front-loaded with the one-line purpose, then the verification prerequisite, then args. The node-type enumeration is long but earns its place by steering the agent away from hand-rolled networks. No filler sentences.

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

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

For a 3-parameter creation tool with no annotations and no output schema, the description covers purpose and a key prerequisite but omits return value, failure modes, and path format conventions. Adequate to invoke, incomplete for a mutation tool.

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

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

Schema description coverage is 0%, so the description must compensate, and it only minimally does: 'Parent network path', 'CHOP node type to create', and 'Node name override' mostly restate the parameter names. The one genuinely useful detail is that name is an override (optional, defaults to the type's default name), but format expectations (e.g. absolute vs relative path) are absent.

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

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

States a specific verb and resource ('Create a new CHOP node') and scopes it to the CHOP context, which distinguishes it from the generic create_node sibling. It does not, however, explicitly contrast itself with create_node or create_cop_node/create_lop_node, so an agent must infer that the CHOP-specific variant is the right choice.

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

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

Gives a concrete precondition ('call list_node_types(context="Chop", filter=...) to verify the correct node type') and warns that dedicated CHOPs like noise, wave, spring, jiggle, lag, or limit may already cover the need. That is real when-to-use guidance, though it stops short of naming the alternative tool to call instead of creating a node.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses useful ecosystem context (COP2 deprecated as of Houdini 20.5, Copernicus preferred) but says nothing about failure modes, whether the parent network must exist, permissions, or what is returned on success.

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

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

Front-loaded with the core action and prerequisite, which is good, but the long enumeration of ~17 node types is verbose relative to its routing value and dominates the middle of the description.

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 creation tool with no annotations and no output schema, the description covers purpose, workflow prerequisite, context selection, and all parameters. It is largely sufficient, with only return/failure behavior left unaddressed.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: it documents all three params inline (parent_path as the parent COP network path, cop_type as the node type, name as an override). It adds meaning beyond the bare schema, though without format examples for parent_path.

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

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

States a specific verb+resource ("Create a COP node") with scope ("in the specified network"), distinguishing it from generic create_node and the sibling create_lop_node/create_chop_node. An agent can tell what the tool produces 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?

Gives a concrete prerequisite (call list_node_types with context='Cop' or 'Cop2' first) and steering advice (prefer Copernicus over deprecated COP2). It doesn't explicitly compare against the generic create_node/create_node-type siblings, so it stops just short of full alternative routing.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a mutation (creating/defining an HDA file) but says nothing about whether the destination file is overwritten, what happens to the source subnet node, required permissions, or error behavior. For a write operation with zero annotation coverage, this is a significant gap.

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

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

The purpose sentence is front-loaded and efficient, but the Args block is boilerplate that largely duplicates the schema and even includes 'ctx: MCP context,' which is not a tool parameter. This noise dilutes an otherwise reasonably sized description.

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

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

With no annotations, no output schema, and 5 parameters at 0% schema coverage, the description should do much more. It does not explain the result of the operation, what the created HDA contains, or how the source subnet is handled, leaving the agent under-informed for a mutating call.

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

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

Schema description coverage is 0%, so the description must compensate, and it does so only thinly. It adds marginal meaning ('Subnet node path' clarifies the node must be a subnet; 'destination HDA file path' clarifies directionality; 'Operator type name'), but most entries just restate the parameter names with little additional syntax or constraint detail.

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

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

The description opens with a specific verb+resource: 'Create a new HDA from an existing subnet node,' which clearly conveys both the action and the source. It does not, however, differentiate itself from close siblings like install_hda, update_hda, or reload_hda, leaving the agent to infer the 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?

There is no guidance on when to use this tool versus the many HDA-related siblings (install_hda, update_hda, get_hda_info, etc.). The usage is only implied by the verb 'Create,' and no prerequisites or conditions are stated.

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

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

With no annotations, the description carries the full behavioral burden but only enumerates parameters. It does not state whether the light is authored into the current stage, what happens on failure, whether an existing node with the same name is overwritten, or what is returned. For a creation/mutation tool this is a real 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?

One front-loaded sentence for purpose followed by a compact, scannable arg list. No filler, though it could omit a few redundant restatements (e.g., "Light intensity" for intensity).

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

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

For a 6-parameter tool with no output schema and no annotations, the parameter coverage is good, but the missing behavioral context (return value, overwrite semantics, required scene state) leaves the definition only minimally adequate 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 0% and the schema defines no enums, yet the description explains all six parameters and crucially enumerates the valid light_type values ("dome", "distant", "rect", "sphere", "disk", "cylinder") and the [r,g,b] / [x,y,z] formats that the schema does not convey. This adds substantial meaning over the raw schema.

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

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

States a specific verb and resource: creating a USD light in a LOP network. An agent can distinguish it from read tools like list_lights and mutation tools like set_light_properties, but it does not explicitly differentiate itself from the sibling create_light_rig (single light vs. a rig).

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 versus create_light_rig or create_lop_node, and no prerequisites (e.g., must a current LOP network exist, does it require a stage). It simply describes an action with no context 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?

With no annotations, the description carries the full behavioral burden. It does not disclose what the rig actually creates (how many lights), whether it overwrites or adds to existing lights, whether it is undoable, or any required context. For a mutation tool with zero annotation coverage this is a real gap.

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

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

The purpose is front-loaded in one sentence, and the args list is terse with no filler. The Args block is a reasonable structure, though it is somewhat list-like rather than prose.

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

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

Parameters are well covered, but for a mutation tool with no annotations and no output schema, the description omits any indication of side effects, what is produced, or undo behavior. It covers the invocation surface but not the behavioral context an agent would want.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: it enumerates the valid preset strings ('three_point', 'studio', 'outdoor', 'hdri'), explains parent_path is a LOP network path, and clarifies intensity_mult scales all light intensities. This is meaningful added semantics for all three parameters, though the schema's 'preset' string has no enum to enforce these values.

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

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

States a specific verb+resource: 'Create a preset lighting rig in a LOP network.' An agent can distinguish it from sibling create_light (single light) by the word 'rig' and 'preset'. It does not explicitly name or contrast against that sibling, keeping it just below a 5.

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

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

There is no when-to-use guidance. The description never says when to prefer this over create_light or set_light_properties, nor any prerequisites (e.g. that a LOP network must exist at parent_path). Usage must be inferred from the name alone.

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

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

With no annotations, the description carries full behavioral burden. It discloses the prerequisite validation step and that prim_path sets a USD prim path on the node, but omits failure modes, undo behavior, name-collision handling, and what the operation returns. The added context is useful but incomplete 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?

Front-loads the core action, then provides a prerequisite and an args list. The list of twelve example LOP types is somewhat verbose but illustrative. Overall the structure is clean and every part serves a purpose, though the example list could be trimmed.

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 purpose, a prerequisite, and brief parameter hints. But for a create tool with no annotations, no output schema, and 0% schema description coverage, it should also describe the return value, side effects, and error conditions. Those gaps leave an agent under-informed about invocation outcomes.

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

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

Schema coverage is 0%, so the description must explain all four parameters. It gives meaningful detail for lop_type (with examples and a validation step) and prim_path (explains its effect), but parent_path and name are essentially tautological restatements. Format expectations, defaults, and requiredness remain unstated.

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

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

States a specific verb and resource: 'Create a new LOP node.' This distinguishes it from generic siblings like create_node and from context-specific creators like create_light. However, it does not explicitly name or contrast with alternative node-creation 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?

Gives a clear precondition: 'Before using this, call list_node_types(context=\'Lop\', filter=\'<keyword>\') to verify the correct node type.' It also explains why this matters by listing many specialized LOPs. No explicit when-not or direct sibling comparison is offered.

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

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

No annotations are provided, so the description carries the full burden. It does disclose one genuine behavioral trait beyond the schema: the name is refused if taken and auto-numbers up from 'material1'. However, it says nothing about persistence, required connection state, or other side effects of creating a material.

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 purpose is front-loaded in a single sentence, followed by an Args block that is uniformly terse. Little waste, though the naming default explanation spans two lines that could be tightened.

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

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

For a creation tool with no annotations and no output schema, the parameter documentation is solid, but the description omits any statement of the returned material handle/node path or the operational context (connection requirement, undo behavior) an agent needs before calling.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: every one of the six parameters gets a meaning and, for the numeric ones, a 0-1 range. Only mat_type is weakly specified, listing enum-like values ('principled', 'materialx') without stating whether others are valid.

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

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

States a specific verb and resource ('Create a material') plus the target location '/mat' and scoping ('configurable surface properties'). It distinguishes reasonably from create_material_network and create_node, though it never explicitly contrasts itself with those siblings.

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

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

No guidance on when to use this versus create_material_network, create_node, or assign_material, and no prerequisites (e.g. a live Houdini connection) are mentioned. The agent must infer usage entirely.

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

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

With no annotations present, the description carries the full burden and does disclose substantial behavior: the canonical key aliasing (base_color/roughness/metalness/opacity mapped per shader type), the rule that unknown keys must match real parameter names, tuple semantics for lists, and the failure surface ('skipped' keys with reasons). It stops short of stating permissions, creation location within /mat beyond the network, or name-collision handling.

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 core action is front-loaded in the first sentence, and the remaining prose is dense but earns its place by explaining the alias mapping and skip reporting. The Args block is standard docstring style; minor verbosity but no filler.

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

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

For a 3-parameter, no-annotation, no-output-schema tool, the description supplies the argument semantics, mutation behavior, and even the shape of the reply (applied list plus 'skipped' reasons), which covers most of what is missing from structured fields. It only lacks tool-routing context relative to its siblings.

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

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

Schema coverage is 0%, so the description must compensate, and it does: name ('Name for the new material node'), shader_type (with concrete values principled/materialx plus arbitrary node types), and params (name-value pairs with the full mapping rules). No parameter is left ambiguous.

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

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

The first sentence gives a specific verb and resource ('Create a new material network in /mat'), so the purpose is unambiguous. It does not, however, distinguish itself from close siblings such as create_material, build_network, or create_node, which an agent must currently do by inference.

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

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

The description never states when to choose this tool over create_material, build_network, or create_node. It offers argument-selection detail (which shader_type values exist) but no tool-selection or exclusion guidance, so the agent gets no routing help.

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 provided, so the description carries full burden. It implies a mutation (creates a box) but says nothing about side effects, whether boxes can overlap or auto-resize, whether the operation is reversible, or whether it affects existing layout. Significant gaps 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?

Single-sentence purpose up front, followed by a compact Args block. No waste. Minor: 'document a graph you built' is slightly editorial.

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

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

For a 4-param mutation tool with no annotations, no output schema, and 0% schema description coverage, the description covers the basics but leaves behavioral and usage gaps that an agent needs to call it confidently.

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

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

Schema description coverage is 0%, so the description must compensate. It documents all four params reasonably: parent_path (network), node_paths (siblings to enclose, box fits around them), comment (title), color (RGB 0..1). This is decent, but color format is only partially specified ('RGB in 0..1') and node_paths behavior when null is unstated. Baseline for low coverage would be lower, but the description does add real meaning — 3 is fair.

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

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

States a specific verb and resource: 'Draw a titled network box around nodes.' Clearly distinguishes from sibling create_sticky_note and create_node. 'document a graph you built' adds a use-case framing, though the phrase is a bit soft.

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

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

No when-to-use vs alternatives guidance, no prerequisites, no note about when a box (vs a sticky note, vs verify_network) is appropriate. Agent must infer intent from the sibling list.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not state that this is a write operation, whether it modifies the scene destructively, what happens on failure, or whether it can be undone. The prerequisite call is helpful but is usage guidance, not a behavioral trait of the tool itself.

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

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

The description is front-loaded with the core action, followed by a useful prerequisite note and parameter list. The middle paragraph about Houdini's thousands of nodes is somewhat tangential but still relevant guidance, and the overall structure is easy to scan.

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

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

Given the absence of annotations and an output schema, the description covers the basic purpose, a key prerequisite, and parameter meanings. It omits important context such as return values, error conditions, and side effects, which are necessary for safe invocation of a node-creation tool in a complex scene graph.

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

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

Schema description coverage is 0%, so the description must compensate. It lists all four parameters and gives brief meanings (e.g., 'Parent network path', 'Node type (e.g. geo, box, grid)', '[x, y] network editor position'), which adds some value. However, it does not clarify path formatting, optionality, or defaults, so the compensation is only partial.

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

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

The description states a specific verb and resource: 'Create a node inside a parent network.' This is clear and direct, but it does not distinguish this tool from sibling creation tools like create_lop_node, create_cop_node, or create_chop_node, which all create nodes in different contexts.

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

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

It gives clear context by recommending a prerequisite call to list_node_types and explains why dedicated nodes are preferable to VEX or Python. However, it does not provide explicit exclusions or compare this tool against other node-creation siblings, leaving an agent to infer when to use create_node versus create_lop_node etc.

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

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

No annotations are provided, so the description carries full burden. It discloses the target location (/out) but says nothing about side effects on the scene, whether the node is automatically connected, required Houdini connection state, error behavior for an invalid renderer, or whether the operation is undoable.

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

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

The description is short and front-loaded with the core action before the argument list. Each argument line is minimal, though the 'Args:' list is essentially a restatement of schema property names with only the renderer enum adding clear value.

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

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

For a mutation tool with no annotations and no output schema, the description is too thin. It omits what the tool returns (e.g., the created node path), whether the operation requires an active Houdini session, and how optional parameters like camera and output_path affect node configuration.

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

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

Schema description coverage is 0%, so the description must compensate. It labels all four parameters and provides the accepted renderer values ('karma', 'opengl', etc.), which is useful beyond the bare schema. However, it gives no format details for camera paths, output path syntax, or name defaults.

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

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

States a specific verb ('Create') and resource ('render (ROP) node') and location ('in /out'). This distinguishes it from generic create_node and from create_lop_node/create_cop_node siblings, though no sibling is named explicitly.

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

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

No guidance on when to use this tool versus alternatives like create_node or setup_render. The description only defines the action and arguments, leaving the agent to infer context from the tool name and parameter list.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies mutation via 'Add' but says nothing about permissions, whether the parameter persists, what happens on a duplicate parm_name, or what is returned — significant gaps for a write operation.

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

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

Front-loaded purpose sentence followed by a compact per-argument list; no filler or repetition. Slightly terse, but every line earns its place.

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

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

For a 7-parameter mutation tool with no annotations and no output schema, the argument documentation is solid but the behavioral story is incomplete — no success/failure semantics, no note on whether the node must already exist or be unlocked, and no return-value indication.

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

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

Schema description coverage is 0%, so the description must compensate, and it largely does: it names all seven parameters and adds real meaning, notably the allowed parm_type values ('float', 'int', 'string', 'toggle', 'menu') which the schema does not enumerate as an enum, and the float/int-only constraint on min_val/max_val.

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

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

The first line states a specific verb and resource ('Add a spare parameter to a node'), which is clear enough to act on. It does not, however, distinguish itself from the near-identical sibling 'create_spare_parameters' (plural), leaving the agent to guess which one to pick.

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

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

There is no when-to-use guidance, no prerequisites (e.g. node must exist, name collisions), and critically no differentiation from the sibling 'create_spare_parameters'. The agent gets no help choosing between the singular and plural variants.

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

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

With no annotations, the description carries the full burden and does well: it discloses upsert semantics (existing labels/defaults/ranges updated, current value and keyframes preserved) and a refusal rule ('a type change on an existing parameter is refused'). It omits auth/permission requirements and any error surface beyond the type-change case.

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?

Purpose is front-loaded, behavioral caveats follow, and Args are itemized. Slightly verbose in restating types, but every sentence carries information an agent needs.

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

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

For a mutation tool with no annotations and no output schema, the definition covers purpose, upsert/refusal behavior, and all parameter semantics. Remaining gaps (error handling beyond type change, permissions) are minor.

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

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

Schema description coverage is 0%, yet the description documents every parameter: node_path, the nested parameters dict keys and allowed parm_type values, folder_name's wrapping behavior, and folder_type's three styles. This more than compensates for the empty 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?

Starts with a specific verb+resource+scope: 'Batch-create multiple spare parameters in one call, optionally in a folder tab.' The word 'Batch' immediately distinguishes it from the singular sibling create_spare_parameter, and no schema inspection is needed to know what it 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 batch framing gives clear context for choosing this over create_spare_parameter, and the upsert note ('a name that already exists is updated in place') tells the agent when re-running is safe. There is no explicit when-not or named alternative, so it falls 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?

With no annotations, the description carries the full behavioral burden, yet it discloses almost nothing about effects: no statement of what the returned value is, what happens if parent_path is invalid, or whether the note is immediately created. It only documents argument units, which is parameter-level, not behavioral, context.

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

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

Front-loads the purpose sentence, then lists args efficiently. However, it includes a non-parameter entry ('ctx: MCP context.') that adds noise, and reads as a raw docstring dump rather than a curated description.

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

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

No output schema or annotations exist, so the description bears full responsibility, and it leaves out what the tool returns and any failure/edge behavior for a mutation tool. The parameter documentation is complete, so it is minimally adequate but not complete.

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

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

Schema coverage is 0%, so the description must compensate, and it largely does: it names all five parameters and adds units the schema lacks – 'position: [x, y] in network editor units', 'size: [width, height] in network editor units', and 'color: RGB in 0..1'. This meaningfully disambiguates format and ordering beyond the bare schema types.

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

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

States a clear verb and resource: 'Leave a sticky note in a network.' An agent understands it creates a note object inside a specified Houdini network. It does not differentiate from any sibling (there is no other note tool), but the purpose itself is unambiguous.

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

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

The description offers no when-to-use or when-not-to-use guidance, no prerequisites, and no mention of alternatives. It is purely a signature listing with no routing context.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says 'create' but omits side effects: whether the new take becomes the current take, what happens to the scene state, whether the operation is reversible, and what is returned. The only behavioral detail is the parent default, which is insufficient 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?

The description is front-loaded with the purpose and then lists the two arguments efficiently. It is appropriately sized for a simple two-parameter tool, though the separate Args block repeats parameter names that could arguably be integrated into the first sentence.

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 low-complexity, two-parameter creation tool with no output schema and no annotations, the description covers purpose and both parameters adequately. However, it leaves out the post-creation state change (current take behavior) and any return or side-effect information, which an agent would need to invoke it with full confidence.

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

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

Schema description coverage is 0%, so the description must document the parameters. It does both: 'name' is called the name for the new take, and 'parent_name' is described as the parent take name with a default of the current take. This adds meaningful default behavior not present in the schema. Only minor format or constraint details are missing.

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

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

The description states a specific verb and resource: 'Create a new take'. It adds scope ('optionally under a parent take'), which helps an agent distinguish it from the read/write siblings like list_takes or set_current_take. However, it does not explicitly name or contrast with those siblings.

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

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

It implies the core use case (making a new take) and mentions the optional parent nesting, but offers no explicit when-to-use guidance, no prerequisites, and no comparison to related tools like set_current_take or list_takes. Usage is implied rather than stated.

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

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

With no annotations, the description carries the full burden and does disclose real behavior: expressions are evaluated before being kept, invalid expressions are discarded ('not kept'), and VEX attribute syntax triggers a refusal naming an alternative tool. It does not say whether an existing expression is overwritten or what is returned on success.

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

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

Front-loaded with the core action and the two key constraints before the Args block. The Args list largely restates the schema field names, so a little space is spent on low-yield content, but nothing is padded or buried.

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 parameter-mutating tool with no annotations and no output schema, the critical unknowns an agent faces (HScript vs VEX, failure semantics) are answered. Remaining gaps are secondary: overwrite behavior for an already-expressioned parameter and permission requirements.

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

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

Schema description coverage is 0%, so the description must compensate, and it does so only minimally: node_path and parm_name get tautological glosses ('Path to the node', 'Parameter name'). The one high-value addition is that vex_code is HScript syntax despite its VEX-sounding name, which offsets the gap partially but not fully.

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

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

The first sentence states a specific verb and resource ('Set an HScript expression on a parameter') plus evaluation timing ('evaluated before it is kept'), which resolves the confusing name (a 'vex_expression' tool that actually sets HScript). It differentiates from the VEX path by naming create_wrangle, though it never distinguishes itself from the near-identical sibling set_expression.

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 an explicit when-not and a routing alternative: parameters cannot run VEX, '@' syntax is refused, and the error points to create_wrangle. What is missing is positive guidance on when this should be preferred over set_expression or execute_hscript.

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 behavioral burden. It usefully discloses the mandatory justification gate and the intended usage discipline, but says nothing about mutation side effects, whether the node is cooked/validated, or what happens on invalid VEX. Adequate but incomplete for a write operation 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?

Front-loaded with purpose, then the critical usage constraint, then Args. The warning block is longer than typical but all of it is actionable and justifies its space by preventing misuse.

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 5-param creation tool with no output schema and no annotations, the description covers purpose, usage gating, and every parameter. It stops short of describing failure modes or post-creation state, keeping it from 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 description coverage is 0%, so the Args section does the work: it defines parent_path, vex_code, justification semantics, node name, and enumerates run_over values ('Points', 'Vertices', 'Primitives', 'Detail', 'Numbers') that the schema lacks. This meaningfully compensates for the empty schema descriptions.

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

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

States a specific verb and resource ('Create an Attribute Wrangle node with VEX code') and implicitly distinguishes itself from siblings like set_wrangle_code and create_vex_expression by scoping to node creation. An agent can immediately tell what this produces.

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 frames the tool as a LAST RESORT, names the categories it must never be used for (modeling, scattering, copying, deforming, grouping, randomizing), and instructs the agent to run list_node_types first. This is textbook when/when-not/alternatives 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?

With no annotations provided, the description carries the full behavioral burden. It states the mutation but omits whether a keyframe must already exist, what happens if none exists at the given frame, whether the deletion is undoable, or what side effects occur on the animation curve. This is a significant gap for a destructive 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 short and front-loaded, stating the action first and then listing parameters. The Args block is compact, though the parameter blurbs are so thin that they barely earn their 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 three-parameter mutation tool with no annotations, no output schema, and 0% schema description coverage, the description is too thin. It does not explain required preconditions (e.g., that the keyframe must exist), the effect on the curve, or error behavior, so an agent lacks enough context to invoke it confidently.

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

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

Schema description coverage is 0%, so the schema only provides titles like 'Node Path', 'Parm Name', and 'Frame'. The description's parameter blurbs ('Node path.', 'Parameter name.', 'Frame number to delete.') mostly restate those titles and add no meaningful format, type, or constraint information beyond what the schema already shows.

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) and resource (keyframe) with scope (at a specific frame), which is enough to tell it apart from set_keyframe and get_keyframes implicitly. However, it does not explicitly differentiate itself from sibling tools, so it falls short of a 5.

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

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

There is no when-to-use guidance, no mention of alternatives such as set_keyframe or get_keyframes, and no prerequisites or exclusions. The description only states what the tool does, leaving the agent to infer usage from the verb alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says only 'Delete a node' and does not disclose whether deletion is reversible, what happens to children/dependents, or what permissions or context are required.

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

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

The description is very short, but it is under-specified rather than efficiently concise. The 'Args:' boilerplate, including 'ctx: MCP context.', does not earn its place and distracts from the only useful statement.

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 tool with no annotations and no output schema, the description is incomplete. It lacks consequences, safety information, and usage context that an agent would need before invoking a delete operation.

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

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

Schema description coverage is 0%, and the description only repeats 'node_path: Node path' without adding format, examples, or path semantics. It does not compensate for the missing schema documentation.

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

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

The description states a clear verb and resource ('Delete a node'), so an agent can tell what the tool does. However, it does not differentiate this tool from siblings such as delete_keyframe, rename_node, or create_node, and adds no scope beyond the tool name.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, required selection state, undo behavior, or the related node-management siblings, leaving the agent to infer usage entirely.

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

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

With no annotations, the description carries the full behavioral burden. It does usefully disclose that remove_outputs deletes output files from disk, but says nothing about whether this marks all items or a subset, whether it requires a subsequent cook, or whether the disk deletion is recoverable.

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 core purpose is front-loaded in one sentence, followed by a compact arg list. The 'ctx: MCP context' entry is boilerplate that adds little, but overall the text is tight and wastes few 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 two-parameter TOP operation with no annotations and no output schema, this is only partly complete: it never states scope (all work items vs. selected), what the agent should do afterwards (cook the node), or what the call returns.

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

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

Schema description coverage is 0%, so the description must compensate. It adds real meaning for remove_outputs ('Also remove output files from disk'), which is the key non-obvious parameter, but node_path is only restated and no format or expected value is given for it.

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

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

States a specific verb and resource — marking work items on a TOP node dirty — and clarifies the goal ('so they can be regenerated'). It is clear what the tool does, but it does not distinguish itself from related TOP tools like generate_static_items or cook_top_node, which an agent must choose between.

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 'so they can be regenerated' implies the usage context (forcing re-cook/re-generation), but there is no explicit when-to-use guidance and no mention of alternatives such as cooking, cancelling, or inspecting work item states. Usage is left to inference.

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

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

No annotations are provided, so the description carries the full burden. For a mutation tool it says nothing about side effects: whether disconnecting is reversible, what happens to downstream cooks, whether the node path must be valid, or what the result looks like. The 'Args' block merely restates parameter names.

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

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

The opening sentence is tight and front-loaded, but the following 'Args:' block is boilerplate that duplicates the schema's property titles without adding information, which weakens the otherwise efficient 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?

A mutation tool with no annotations, no output schema, and 0% parameter coverage needs the description to explain side effects and parameter interplay. It does not, leaving an agent unable to predict the tool's behavior from the definition alone.

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

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

Schema description coverage is 0% for 3 parameters, and the description does not compensate. The arg list ('Node path.', 'Input index to disconnect.', 'Disconnect all inputs.') echoes the schema titles verbatim, adding no format, range, or interaction semantics (e.g., how input_index and disconnect_all combine).

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

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

States a clear verb+resource: 'Disconnect one or all inputs of a node.' An agent immediately knows the operation. However it does not differentiate itself from closely related siblings such as connect_nodes, connect_nodes_batch, or reorder_inputs, so a 5 is not warranted.

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 versus connect_nodes/connect_nodes_batch, no mention of prerequisites (e.g., that the node must exist or be connected), and no explanation of when to prefer disconnect_all over input_index. Usage must be inferred entirely.

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

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

With no annotations, the description carries the full burden and does so: atomic copy-then-write semantics ('a failing op changes nothing'), collision checking, the built-in-parameter constraint with the reinstated_by_houdini reply field, and dry_run behavior. This is exactly the behavioral detail an agent needs before mutating an HDA definition.

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

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

It is front-loaded (purpose, then the append-only distinction, then the atomicity guarantee, then op grammar) and every block is functional. It is long, but the length is driven by a genuinely complex op grammar with 0% schema coverage; only the parenthetical alias notes feel slightly compressible.

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, yet the description surfaces the relevant reply fields (reinstated_by_houdini, stored, instance_expression_errors) and the failure semantics. For a 3-parameter, high-complexity mutation tool with no annotations, nothing material 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 0%, so the description must compensate, and it does: it fully enumerates the op dict grammar (insert/remove/hide/show/replace/modify/move), each op's positional keys, the spec fields, naming variants and aliases, and the meaning of node_path and dry_run. This exceeds what a bare schema would have 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 opening sentence states a specific verb (edit), resource (an HDA's EXISTING Type Properties interface), and enumerates the six supported operations. It also explicitly distinguishes itself from the sibling set_hda_interface ('only appends'), so an agent can route between the two without opening a 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?

It names the alternative (set_hda_interface appends; this tool edits existing entries) and states the prerequisite workflow ('Read the interface first with get_parm_template_tree'). The dry_run parameter and the read-first instruction give clear when-to-use and when-to-call-something-else guidance.

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

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

No annotations are provided, so the description carries the full disclosure burden. It notes a return result but says nothing about side effects even though evaluating hscript or python can mutate the scene, nor about errors, cost, or whether execution is sandboxed. For a code-evaluation tool with zero annotation coverage this is a notable gap.

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

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

The action statement is front-loaded in the first sentence and the per-argument notes are compact. There is no filler, though the bare 'Args:' block is functional rather than polished.

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 and no annotations, the description should do more for a tool that executes arbitrary code. It covers the two parameters at a basic level but omits defaults, side-effect risk, and return-shape details, leaving an agent with an incomplete picture for a 2-parameter eval tool.

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

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

Schema description coverage is 0%, so the description must compensate, and it usefully enumerates the allowed language values ('hscript' or 'python'), which the schema does not express as an enum. It does not state the default (hscript) or the required/optional status of expression, so it partially compensates.

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

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

The description gives a clear verb+resource ('Evaluate an expression in Houdini') and states it returns a result, so an agent knows what the tool does. However, it does not distinguish itself from close siblings like execute_hscript, execute_python, or set_expression, leaving the agent to infer the boundary.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no mention of the near-identical siblings execute_hscript and execute_python. The only implied guidance is that you supply an expression, which is too thin to route the agent reliably.

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

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

No annotations are provided, so the description carries the full burden, yet it discloses nothing about side effects, whether the command can mutate or destroy scene state, required context, or error behavior. For an arbitrary command-execution tool this is a significant gap.

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

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

Front-loaded and brief with no wasted sentences. The 'Args:' block largely restates the parameter name already in the schema, but the overall size is appropriate.

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

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

For an arbitrary-command execution tool with no annotations, no output schema, and 0% parameter schema coverage, the description omits almost everything an agent needs: side effects, safety profile, return behavior, and execution context. It is substantially under-specified for the tool's risk level.

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

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

Schema coverage is 0% and the single parameter is undocumented in the schema, so the description must compensate. It adds only that the value is an HScript command string, which distinguishes it from Python code but gives no syntax, format, or examples. Minimal but non-zero added 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?

States a specific verb and resource: 'Execute an HScript command in Houdini.' An agent knows what the tool does, and the HScript qualifier separates it from execute_python. However, it does not explicitly contrast itself with sibling command-execution tools, so it stops short of a 5.

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

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

No when-to-use guidance, prerequisites, or alternatives are given. The description never explains when HScript execution is preferable to execute_python, run_shelf_tool, or evaluate_expression, nor any 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?

No annotations are provided, so the description must carry the behavioral burden, and it does meaningfully: it discloses that this runs arbitrary code with unrestricted hou.* access, that a written justification is mandatory, and how results are retrieved via return_expression. It does not, however, state anything about side-effect persistence, sandboxing, error/exception behavior, or what happens on failure.

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

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

Front-loaded with the critical constraint ('LAST RESORT only') before the bullet list, and the bullets are scannable. Slight redundancy between the opening line and the closing 'ONLY use this when...' restatement, but overall dense and well organized.

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 three-parameter escape-hatch tool with no annotations and no output schema, the description covers purpose, routing, gating policy, and all parameters. It could say more about return value shape or execution environment limits, but nothing essential for correct invocation is missing.

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

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

Schema description coverage is 0%, so the description must compensate, and the Args block documents all three parameters: code as Python source, justification as the required rationale, and return_expression as a post-execution expression. It lacks detail on return_expression syntax or code size limits, but the semantic intent of each parameter is clear.

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

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

States a specific verb and resource ('Execute arbitrary Python code inside Houdini') and immediately scopes it as a LAST RESORT. The do-not-use list names the exact sibling tools that cover each neighboring capability, so an agent can distinguish this tool from build_network, create_wrangle, connect_nodes, etc. without opening any 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?

Explicit when-not-to-use routing for five categories of operation, each paired with the correct alternative tool, plus a positive trigger ('ONLY use this when no dedicated tool exists... hou.* API calls or Python-level state'). The mandatory justification requirement reinforces the gating condition. This is textbook when/when-not/alternatives guidance.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing. It doesn't state what the 'explanation' contains, whether it is read-only, costly, or requires the node to exist. For a tool whose entire value is the shape of its human-readable output, this is a substantial 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?

It is short and front-loads the core verb phrase, which is good, but the trailing 'Args:' block is boilerplate that repeats the parameter name without adding information. Adequately sized, but it earns little of its small footprint.

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

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

With no annotations, no output schema, and an undocumented parameter, the description should carry the load – and it doesn't. An agent still cannot predict what calling this returns or when it succeeds versus fails.

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

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

Schema description coverage is 0% and the description only offers 'node_path: Node path.', which merely restates the parameter name. It adds no format, validity, scope, or path-syntax meaning to compensate for the empty 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 verb ('Explain') and a resource ('a node') but 'explain' is ambiguous – it doesn't say whether this returns documentation for a node type, an instance, or its parameters. With dozens of siblings like get_node_info, get_node_card, and get_node_errors_detailed, no differentiation is offered, leaving the agent to guess how this differs.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives. The agent cannot tell from the text whether to reach for explain_node versus get_node_info or get_node_card when it wants information about a node.

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. The phrase 'via a chop() expression' usefully reveals the mechanism is a write to the target parameter's expression, but it does not say whether an existing expression is overwritten, what happens on invalid paths, or whether the result is evaluated immediately (a cook).

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 purpose followed by a compact Args list; nothing is padded. The structure is front-loaded and easy to scan, though the Args block mostly mirrors the schema property names.

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

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

For a mutation tool with no annotations, no output schema, and zero schema descriptions, the definition omits failure modes, whether this requires an active Houdini connection (relevant given connect_houdini/get_houdini_connection_status siblings), and what the caller should verify afterward.

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

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

Schema description coverage is 0%, so the description must compensate. The Args block does clarify each of the four parameters ('Channel to export', 'Parameter to receive the export'), which resolves direction and role beyond the bare property names. It still does not specify path formats or whether a full channel list is needed, so compensation is only partial.

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

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

States a specific verb and resource ('Export a CHOP channel to a parameter') and even names the mechanism (chop() expression), so the action is unambiguous. It does not, however, distinguish itself from near siblings such as set_expression or link_parameters, which likely also write expressions onto parameters.

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 versus set_expression, link_parameters, or set_parameter, all of which live in the same sibling set and could plausibly achieve overlapping results. No prerequisites (e.g. target CHOP must exist/cook) are mentioned.

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

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

With no annotations, the description carries the full burden and does so well: it discloses that success is verified via `wrote_files` (a file appeared or changed, not just a returned call), that a /out ROP's output path is restored afterwards, and that a frame_range writes `name.0001.ext` per frame while leaving the playbar unchanged. These are exactly the side effects an agent needs.

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

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

Front-loads the action in the first sentence, then layers behavior and an Args block. Dense but each sentence earns its place; the prose paragraph is slightly heavy relative to the small parameter set.

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

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

No output schema or annotations exist, but the description covers return semantics (wrote_files / success) and key side effects, which is strong for a 3-param mutation tool. It could say more about failure modes or what happens on partial frame exports, leaving a small gap.

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

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

Schema description coverage is 0%, so the description must compensate, and it documents all three params: node_path's role, file_path with the ROP override semantics, and frame_range's [start, end] / [start, end, step] shapes. It stops short of restating types/defaults, keeping it just below full credit.

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

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

States a specific verb and resource ('export a node's output to a file on disk') and goes further by enumerating how it behaves for SOPs, LOPs, and /out ROPs. This lets an agent distinguish it from siblings like save_scene, start_render, write_cache, and import_file without opening any schema.

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

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

The description explains per-node-type behavior and the ROP override, which implies when the tool applies, but it never names an alternative (e.g., start_render or write_cache) or states when NOT to use it. Usage is inferrable rather than explicit.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only scan but never states it, does not describe whether it walks children recursively, whether it cooks nodes to surface errors, or how errors vs warnings are reported. Only the most basic behavior is conveyed.

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

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

The core sentence is tight and front-loaded, but the appended 'Args:' block merely echoes the parameter name with no added information, which is padding rather than 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?

For a diagnostic tool with no annotations and no output schema, the description should specify what comes back (node paths? messages? severity?) and whether the search is recursive. None of that is present, leaving the agent unable to anticipate the response shape.

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

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

Schema description coverage is 0%, so the description must compensate, but it only restates the parameter name ('root path to search from'). It adds no path syntax, no indication of whether child networks are traversed, and the default '/' appears only in the schema.

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

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

States a specific verb and resource: find nodes that carry errors or warnings. Clear enough to act on, but it never distinguishes itself from close siblings like get_node_errors_detailed or verify_network, so an agent cannot tell which of these overlapping diagnostics to pick.

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

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

No when-to-use guidance, no prerequisites, no mention of alternatives such as get_node_errors_detailed or get_cook_status. The agent is left to infer that this is a scene-wide scan starting at a root path.

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

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

With no annotations, the description carries the full burden, and it discloses the crucial non-obvious side effect: the tool records a performance profile while force-cooking display outputs under root_path, i.e. it actively triggers cooks rather than passively reading. It also explains that cook_ms is cumulative so parents include children, which is essential for correct interpretation.

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

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

Front-loaded with the purpose, then the mechanism, then the metric caveat, then args. The opening phrasing is slightly editorial but every sentence adds usable information with little waste.

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

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

For a no-annotation, no-output-schema, three-parameter profiling tool, the description covers purpose, mechanism, metric semantics, and all params. It stops short of describing the exact shape of the returned ranked list, but that gap is minor.

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

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

Schema coverage is 0%, so the description must compensate, and it does: root_path is described as a geo container or '/' broadly, frame as an optional jump before cooking, and limit as the max nodes returned. This meaningfully exceeds the bare schema defaults.

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

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

Specific verb+resource: it profiles cooking and ranks the most expensive nodes. It clearly distinguishes itself from passive introspection siblings like get_cook_chain or get_cook_status by being the active hotspot finder.

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?

Frames the use case well ('how a senior artist finds the slow node instead of guessing') and explains the cumulative cook_ms comparison logic for locating hotspots. It does not name explicit alternatives or state when NOT to use it, so it falls just 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?

No annotations are provided, so the description carries the full behavioral burden. It does not disclose whether the operation is read-only, what the return format is, whether distances or point indices are returned, how ties or no-result cases are handled, or any performance constraints.

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

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

The description is short and front-loaded, with the core purpose stated first followed by per-argument clarifications. The args block is slightly redundant for 'node_path' but overall the text is appropriately sized and each sentence serves a purpose.

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

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

With no output schema and no annotations, the description should explain return values or result shape, coordinate space, and node-type applicability. It omits all of these, leaving key context missing for an agent that needs to invoke and interpret the 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 0%, so the description must compensate. It adds useful meaning for 'position' as [x, y, z] and for 'max_results' as max nearest points to return, but 'node_path: Node path.' is essentially a restatement of the schema title and adds no real semantics.

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

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

The description states a specific verb and resource: 'Find the nearest point(s) to a given position.' It clearly conveys the core operation but does not differentiate this tool from related geometry-query siblings such as sample_geometry, get_points, or find_usd_prims.

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

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

There is no explicit guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. The purpose implies a use case, but the description provides no routing information for an agent choosing among many sibling 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses a useful performance/scalability warning (unfiltered search scans the entire scene and returns hundreds), but does not explicitly state that the operation is read-only, nor describe side effects or return format.

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

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

Front-loads the purpose, then usage constraint, then parameter details in a clear structure. It is appropriately sized and every sentence mostly earns its place, though the Args section includes an extraneous 'ctx' entry.

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

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

For a four-parameter search tool with no annotations and no output schema, the description covers purpose, usage, filter parameters, and a performance warning. It is missing a description of the return value (e.g., list of node paths) and an explicit safety profile, which are relevant given the absence of structured metadata.

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

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

Schema description coverage is 0%, so the description must compensate. It provides examples for pattern ('box*'), node_type ('box', 'null'), context ('Sop', 'Object'), and the default for inside ('/'), which adds value. However, it also lists 'ctx' (MCP context), which is not a schema property, introducing potential confusion.

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 'Search for nodes' and the resource, plus the filter dimensions (name pattern, type, context). It is clearly a search tool, distinguishing it from list_children or get_node_info, but does not explicitly name or differentiate from those siblings.

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

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

Gives explicit guidance to narrow the search using 'inside' and at least one filter, and warns that unfiltered root search returns hundreds of nodes. It does not mention when to prefer sibling tools like list_children, so no explicit alternatives are provided.

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

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

With no annotations, the description carries the full burden, and it does disclose one valuable non-obvious trait: the default walk never visits instanceable prototypes, so traverse_instance_proxies must be set to reach them. It does not state read-only nature, result size, ordering, or performance characteristics.

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 summary sentence followed by a compact Args block; every line adds information and the purpose is front-loaded. No padding or restated boilerplate.

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, annotations, or sibling differentiation, the description should ideally say what a match returns (prim paths? full paths?) and whether the search is scoped to the node's stage. It covers the parameters well but leaves the return shape and comparative positioning unspecified.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: it maps node_path to "LOP node path", explains pattern accepts globs (*, **) or a substring, and clarifies the non-obvious semantics of traverse_instance_proxies. Only the exact pattern-matching precedence is left ambiguous.

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

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

The first sentence gives a specific verb and resource ("Search USD prims") plus the mechanism (path pattern), which is clearer than the vague sibling tools. However, it never distinguishes itself from close siblings like list_usd_prims or get_usd_prim, so an agent must guess which one to pick.

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

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

There is no explicit when-to-use guidance and no mention of alternatives such as list_usd_prims or get_usd_prim. The pattern syntax note hints at how to call it, but nothing tells the agent when this tool is the right choice over its 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?

No annotations are provided, so the description carries the full burden. It usefully clarifies that node framing uses the targets' world bounds rather than the whole scene spread, but it does not state whether this alters the camera, selection, or scene state, nor whether it is undoable.

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

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

Front-loaded summary sentence followed by a compact per-argument list; every line earns its place. Slight verbosity in the node_paths explanation but no filler.

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

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

For a three-param viewport tool with no annotations and no output schema, the description covers behavior and argument formats adequately. It omits what happens on success, the default pane when pane_name is null, and how it relates to frame_selection, which an agent would still want.

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

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

Schema description coverage is 0%, so the description must compensate and largely does: node_paths is explained as framing objects/SOPs by their world bounds, and bounds is given as [xmin, ymin, zmin, xmax, ymax, zmax] in world space. pane_name is only glossed as 'Pane tab name', leaving default/null behavior unstated.

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 (frame) and resource (viewport geometry) with three scoping modes (all, node_paths, bounds). It does not name the nearby sibling frame_selection, so an agent must infer the distinction between framing everything/selection from names alone.

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 covers when to use each mode: omit arguments to frame everything, pass node_paths to frame specific objects/SOPs, or pass bounds for a box. There is no explicit when-not guidance or reference to alternatives such as frame_selection, leaving mode selection partly 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 full burden. It never states what happens if nothing is selected, whether the viewport change is undoable, whether it affects only the active pane, or what the null pane_name default means. Only the literal action 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?

One action sentence plus a terse Args block, front-loaded with the action. Efficient, though the Args formatting adds no substance beyond 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?

A viewport-mutating tool with no annotations, no output schema, and one undocumented optional parameter. The description omits the preconditions and defaults an agent would need to invoke it reliably.

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

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

One parameter at 0% schema description coverage. 'Pane tab name' merely restates the schema's title, and the description does not explain the nullable/default behavior (presumably the current pane when omitted). It fails to compensate for the coverage gap.

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

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

States a specific verb and resource: it frames the current selection in the viewport. This implicitly distinguishes it from frame_all, but the sibling is never named, so the agent must infer the boundary itself.

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

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

No when-to-use guidance, no prerequisites (e.g. that a selection must exist), and no mention of the obvious alternative frame_all. The agent gets no routing help.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the key trait that no cooking occurs, but says nothing about whether existing work items are replaced, whether the node is dirtied, idempotency, required node state, or return behavior for a state-mutating tool.

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

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

The core sentence is front-loaded and tight, but the trailing 'Args: ctx: MCP context.' is noise — ctx is not in the input schema — and the node_path arg restates a param already in the schema. Some content does not earn its place.

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

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

With no annotations, no output schema, and 0% schema coverage, the description is too thin for a tool that mutates TOP graph state. An agent cannot determine side effects, preconditions, or what is returned from what is written here.

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

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

Schema coverage is 0% and the description names only one param, but it does add real meaning by specifying 'TOP node path' where the schema only says 'string'. That compensates for the coverage gap partially, though no format, example, or error condition is given.

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

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

The description states a specific verb (generate), a specific resource (static work items), and adds a scoping qualifier (on a TOP node, without cooking). 'Without cooking' meaningfully separates it from sibling cook_top_node, so an agent can tell them apart. It falls short of 5 only because 'static' is left undefined.

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

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

The phrase 'without cooking' implicitly signals when to use this over cook_top_node (generate the item graph without executing it), but there is no explicit when-to-use, when-not, or named alternative. Usage is inferable rather than stated.

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

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

No annotations are provided, so the description carries full behavioral burden. It discloses the frame-cooking side effect ('frames cooked in increasing order, the current frame put back') and output shape (per-component vector ranges, element_count meaning), but does not explicitly state read-only safety, performance cost, or error behavior. This is strong but not fully exhaustive for an unannotated 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 front-loads purpose and usage before a structured Args section. Each sentence earns its place: the 60k-point example concretizes the contrast, and the frame/vector details are necessary given zero schema descriptions. 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?

With no output schema and 0% schema coverage, the description supplies missing return-value semantics (min/max/mean/sum, per-component ranges, element_count, per-frame rows) and usage context. An agent has everything needed to invoke it correctly.

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

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

Schema description coverage is 0%, and all six parameters are undocumented in the schema. The description compensates by explaining every parameter: attrib_class values and hints, frames behavior and output rows, node_paths mutual exclusivity with node_path, and percentiles example with median. This goes well 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?

States 'Aggregate statistics for numeric attributes: min, max, mean, sum' – a specific operation and resource – and contrasts with get_geometry_info and get_attrib_values to distinguish output types. An agent can immediately tell this tool returns summaries rather than raw data.

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 says to use this 'to prove something is happening, rather than reading values', and names two alternatives (get_geometry_info, get_attrib_values) with the reason each is unsuitable on large caches. This provides clear when-to-use guidance and alternative routing without inference.

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

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

No annotations are provided, so the description carries the full behavioral burden. It fails to disclose whether this is read-only, what metadata is returned, error behavior for missing attributes/nodes, or output format.

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?

Very terse and front-loaded. The Args block is somewhat redundant with the schema parameter names, but the description contains no wasted prose.

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

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

This is a read operation with no annotations, no output schema, and zero schema description coverage. The description should clarify what metadata is returned and typical use cases, but instead leaves major gaps for the agent.

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

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

Schema coverage is 0%, so the description must compensate. It lists all three parameters and provides the meaning for attrib_class ('point', 'prim', 'vertex', or 'detail'), which is genuinely useful. However, node_path and attrib_name are only described tautologically ('Node path.', 'Attribute name.') without format details.

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

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

States a clear verb+resource: 'Get metadata for a geometry attribute.' This distinguishes it from siblings like get_attrib_values, get_attrib_stats, and get_geometry_info, though it doesn't explicitly name them. The core purpose is unambiguous.

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

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

No guidance on when to use this tool versus alternatives like get_attrib_values or get_attrib_stats. The description is purely definitional with no usage context or exclusions.

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