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

No annotations are provided, so the description carries the full burden. It only restates the mutation ('Create a new node') and omits side effects, naming/collision behavior, persistence, required connection state, or response format. This is not misleading but is too sparse to be transparent.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. However, it is so minimal that its brevity comes at the cost of valuable usage and behavioral context.

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

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

For a mutating tool with no annotations and no output schema, the description is incomplete: it doesn't mention the required parent/type relationship beyond the schema, expected output, or when to use it. The tool has 5 parameters and 12 siblings, yet the description provides no context to disambiguate invocation.

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

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

The input schema has 100% description coverage, so the baseline applies even though the tool description says nothing about parameters. The schema already documents parentPath, nodeType, nodeName, detailLevel, and responseFormat. No additional parameter meaning is added by the description.

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

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

The description clearly states the operation: 'Create a new node in TouchDesigner.' It distinguishes itself from sibling tools like delete_td_node and get_td_nodes by the create operation, though it does not add any operational scope or parameter context.

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, alternative tools, prerequisites, or exclusions are provided. An agent must infer from the schema and sibling names that this tool is for adding a node, while tools like update_td_node_parameters and exec_node_method exist for other operations. The description gives zero usage guidance.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It states that the tool deletes a node but does not disclose whether the action is irreversible, what happens to connected references/dependencies, whether confirmation is required, or what the result/return value looks like. For a destructive operation this is a significant transparency gap.

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

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

The description is a single, focused sentence with no filler or redundant explanation. It front-loads the verb and resource and earns its place as a concise definition.

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

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

For a destructive tool with no annotations and no output schema, the description is too thin. It does not mention irreversibility, side effects on dependent nodes, error cases, or what output to expect, leaving an agent without enough context to anticipate consequences.

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

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

Schema description coverage is 100%, so the schema already documents the nodePath parameter and the output formatting parameters. The description adds no parameter-level meaning, but the baseline of 3 applies because the schema does the required work.

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

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

The description uses a specific verb ('Delete') and a clear resource ('an existing node in TouchDesigner'). It stands apart from sibling tools like create_td_node and update_td_node_parameters, making the tool's role immediately obvious.

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

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

There is no guidance about when to use this tool versus alternatives, nor any mention of prerequisites or conditions. The intended use is only implied by the verb 'delete' and the resource 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 of behavioral disclosure. It communicates the core action (generating a manifest) and a qualifier ('filesystem-oriented'), but does not explain what that orientation means, whether the operation is read-only, or how results are organized. This is a partial disclosure with a noticeable gap.

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

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

The description is a single sentence with no filler, front-loading the action and object. Every word earns its place, and it is appropriately sized for a simple manifest-listing tool.

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

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

There is no output schema, so the description should clarify what the manifest contains and how the parameters shape it. The unexplained 'filesystem-oriented' term and absence of any return-value detail leave an agent uncertain about the response structure and tool scope.

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

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

Schema description coverage is 100%, so the baseline of 3 applies. The description adds no extra meaning about how filter, detailLevel, or responseFormat affect the generated manifest, leaving parameter interpretation entirely to the schema.

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

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

The description uses a specific verb ('Generate') and a specific resource ('manifest of available TouchDesigner tools'), which distinguishes it from sibling tools that fetch specific details. However, the modifier 'filesystem-oriented' is unexplained and may confuse an agent about the exact scope.

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

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

The description offers no guidance on when to use this tool versus siblings like get_td_classes or get_td_info. It does not state exclusions, prerequisites, or preferred scenarios. Usage must be inferred entirely from the name and 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 provided, the description carries the full burden of behavioral disclosure, but it only says 'Execute a method' with no mention of side effects, mutation risk, method validation, error behavior, or whether methods can modify the TouchDesigner scene state. It does not contradict any annotations, but it also fails to inform the agent about potential destructive or irreversible operations.

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

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

The description is a single, direct sentence with no filler or redundancy. It front-loads the core action and target, making it immediately scannable, and it earns its place by conveying the essential purpose without unnecessary elaboration.

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

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

The tool has six parameters, no output schema, and no annotations, yet the description supplies only the basic action and target. It does not explain what the method call returns, whether arbitrary methods are allowed, how arguments map to the call, or any safety considerations — leaving significant gaps for an agent attempting 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 100%, so the schema itself documents all six parameters, including the nodePath example and the args/kwargs purpose. The description adds no parameter-level detail beyond the schema, so the baseline of 3 applies — adequate but not enhanced by tool-level context.

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

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

The description states a clear verb and resource — 'Execute a method on a specific node' — which names the action and target distinctly. It partially distinguishes the tool from siblings like execute_python_script by focusing on node-specific methods rather than general Python execution, but it does not explicitly contrast with any sibling.

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

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

The description gives no guidance on when to use this tool versus alternatives such as execute_python_script or update_td_node_parameters. There is no mention of when a method call is preferred over parameter updates or arbitrary script execution, leaving the agent to infer appropriate usage.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Execute a Python script' and lists output formatting options, but it does not warn about potential side effects (e.g., modifying the TouchDesigner environment, executing arbitrary code), require any permissions, or explain error handling. The description adds minimal behavioral context beyond what the name implies.

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

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

The description is a single, efficient sentence that states the core action and lists the two optional parameters inline. It is front-loaded with the purpose and avoids unnecessary verbosity. It earns a 4 because it is concise, though the parenthetical parameter listing is somewhat redundant with the schema.

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

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

Given that this tool executes arbitrary Python code, the description is incomplete. It does not explain the execution environment (e.g., how to reference TouchDesigner objects), potential side effects, error handling, or what the script is expected to return. The output format options are mentioned, but the description lacks essential context for an agent to use the tool safely and effectively.

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

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

The schema description coverage is 100%, so the baseline is 3. The description repeats the enum values for detailLevel and responseFormat but adds no additional meaning beyond what the schema already provides. It doesn't clarify the semantics of the 'script' parameter beyond the example, which is already in the schema. Thus, no extra value is added.

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

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

The description clearly states a specific verb ('Execute') and resource ('Python script in TouchDesigner'), which distinguishes it from the sibling tools that are mostly about querying or modifying nodes. However, it doesn't explicitly differentiate itself from siblings like exec_node_method or update_td_node_parameters, so it loses a point for not naming alternatives. Overall, the purpose is unambiguous and specific.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to prefer it over update_td_node_parameters, exec_node_method, or any other sibling. There are no conditions, exclusions, or recommendations, leaving the agent without direction on 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 provided, the description carries the responsibility for behavioral disclosure. 'Get information' implies a read-only operationaging, and the parenthetical hints at output controls, but the description does not state what information is returned, how formatting/detail levels behave, or any side-effect-free guarantee.

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

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

The description is a single efficient sentence with the core purpose front-loaded first. There is no redundant wording, though the parenthetical is somewhat terse and could be more informative.

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

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

The schema richly documents all parameters)Skip retries and enums, but the description itself is minimal morale and there is no output schema. It does not explain what kind of class/module information is returned or how detailLevel affects the response, so it is minimally viable rather than complete.

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

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

Schema description coverage is 100%, so the schema already fully documents className, limit, detailLevel, and responseFormat. The description mentions only 'detailLevel+limit supported', which adds little semantic value beyond restating parameter names that the schema already describes.

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

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

The description states a specific action ('Get information') on a clear resource ('TouchDesigner class/module'), so an agent can understand what the tool does. However, it does not explicitly differentiate this from siblings like get_td_classes or get_td_module_help, so it stops 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?

The description gives no guidance on when to use this tool versus alternatives. It does not mention prerequisites, exclusions, or the relationship to sibling tools such as get_td_classes or get_td_module_help, leaving selection context entirely to the agent to infer.

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 fully disclose behavior. 'List' implies a read-only operation, but the description does not state return format, default detail level, pagination behavior, or any side-effect guarantees. This is minimal but not misleading.

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

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

A single, front-loaded sentence conveys the core purpose with no filler. Every word earns its place, and the key parameters are highlighted compactly.

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 listing tool with fully documented parameters, the description is minimally viable. However, with no output schema and no annotations, it could better explain what the returned list contains or how to choose between sibling tools.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description only adds 'detailLevel+limit supported', which does not enrich the meaning beyond what the enum descriptions already provide.

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

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

The description uses an explicit verb-resource pair ('List TouchDesigner Python classes/modules'), which clearly states the tool's purpose. It partially distinguishes from siblings like get_td_class_details, though it does not explicitly name the 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 use this tool versus get_td_class_details, get_td_module_help, or get_td_info. The mention of 'detailLevel+limit supported' hints at configurable output but provides no decision criteria for choosing this tool 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states 'get', which implies a read-only operation, but it does not explicitly confirm that, nor does it disclose any other behaviors such as output format, error handling, or performance implications. For a read-only tool this is minimal but still insufficient given the absence of annotations.

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

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

The description is a single short sentence, which is concise but under-specified. It front-loads the verb and resource, which is good, but it lacks the detail needed to be fully useful. It is not verbose, but it is also not appropriately sized because it omits crucial context that would make it more actionable.

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

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

Given the tool's simplicity (2 optional params, no output schema, no annotations), the description is still incomplete. It does not explain what 'server information' includes, what the response looks like, or when to use this tool relative to others. The lack of any behavioral or usage context makes it insufficient for an agent 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?

The input schema covers 100% of the parameters (detailLevel and responseFormat) with enums and descriptions. The description adds no additional parameter semantics beyond what the schema already provides. Since schema coverage is high, the baseline score of 3 is appropriate, and the description does not need to compensate.

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 'Get server information from TouchDesigner' clearly identifies the action (get) and the resource (server information). It is specific enough to avoid being a tautology, but it does not differentiate from sibling tools like get_td_nodes or get_td_node_errors, which also retrieve TouchDesigner data. The lack of sibling distinction holds it back from a 5.

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

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

The description provides no guidance on when to use this tool versus the many siblings. It does not mention alternatives, exclusions, or any context that would help an agent decide between get_td_info and get_td_nodes or get_td_class_details. This leaves the agent to infer usage, which is inadequate.

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

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

There are no annotations, so the description carries the full behavioral burden. It correctly indicates that the tool retrieves Python help() text and implies a non-mutating read operation, but it does not disclose error behavior for unknown module names, output size, or how detailLevel changes the returned content.

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

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

The description is a single, front-loaded sentence with no filler or repetition. Every word contributes to identifying the tool's action and target resource.

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 relatively simple read-only help tool with fully documented parameters, the description is mostly adequate. However, with no annotations, no output schema, and overlapping sibling tools, a brief note on when to use it or what happens with invalid input would improve completeness.

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

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

The input schema already documents all three parameters, including examples for moduleName and enums for detailLevel and responseFormat, so schema coverage is 100%. The description adds no additional parameter-level semantics, making the baseline 3 appropriate.

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

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

Description states a specific verb ('Retrieve') and direct object ('Python help() text for a TouchDesigner module or class'), so the action and resource are clear. It does not explicitly contrast with the similar-sounding get_td_class_details, but the help() result type makes the purpose distinguishable.

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

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

No guidance is given for when this tool should be used instead of siblings like get_td_class_details, get_td_info, or get_td_classes. The agent must infer the intended use case from the name and description 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 burden. It discloses important nuances: hasErrors=false does not imply health, and the tool only reads error/warning streams, not exceptions from Script OPs. This goes beyond a simple read operation, revealing limitations. It doesn't cover auth or rate limits, but for a tool like this, the key behaviors are well documented.

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

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

The description is two sentences, each earning its place. It front-loads the core purpose, then adds critical caveats. There is no fluff or repetition. It is succinct yet comprehensive, covering both what it does and what it doesn't.

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

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

Given the tool complexity (hierarchical error checking) and no output schema, the description provides essential context: what streams are checked, what is excluded, and how to interpret results. It also includes examples of error types. An agent has enough to call it correctly and interpret the response without surprise.

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

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

Schema coverage is 100%, so all parameters are described in the schema (e.g., nodePath, limit, detailLevel, responseFormat). The description adds no extra parameter-specific meaning beyond what the schema already provides. It doesn't elaborate on how limit affects output or how detailLevel changes the report, so it stays at the baseline 3.

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

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

The description clearly states it checks errors and warnings on a node and its descendants, with a specific verb (check) and resource (node errors/warnings). It distinguishes itself from sibling tools like get_td_info (which likely provides general info) and get_td_nodes (listing nodes). The examples of missing files, dangling references, and shader compile failures add precision.

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 tells when to use it: when you need to check for errors/warnings on a node hierarchy. However, it lacks explicit guidance on when NOT to use it (e.g., for fetching node properties, use get_td_node_parameters) or alternatives. It does warn against misinterpreting results, which is helpful, but doesn't reference sibling tools or exclusion scenarios.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It does add useful behavioral detail: output can be concise/detailed and the limit parameter caps the formatted output. However, it does not describe error behavior for invalid node paths or the structure of the returned parameter data, though the verb 'get' implies a read-only 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 one short sentence with the main action front-loaded and no filler. The parenthetical 'detailLevel+limit supported' is telegraphic but compact and communicates the key formatting-related parameters without wasting 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?

The tool has four parameters, no output schema, and no annotations, so the description must supply most of the context. It covers the formatting dimension but omits what a returned parameter set contains, error/edge behavior, and how this tool relates to sibling tools. It is minimally viable rather than fully complete.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters including nodePath, detailLevel, limit, and responseFormat. The description only mentions detailLevel and limit, adding no meaning beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description opens with a specific verb+resource: 'Get node parameters,' and adds that it supports 'concise/detailed formatting,' so the core action is identifiable. It is distinguishable from siblings like get_td_nodes or update_td_node_parameters by the word 'parameters,' but it never explicitly contrasts itself with them and leaves 'node parameters' 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?

There is no statement of when to use this tool instead of get_td_nodes (listing nodes), update_td_node_parameters (modifying parameters), or get_td_node_errors. No exclusions, alternatives, or preconditions are mentioned, so an agent must infer applicability solely 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?

No annotations are provided, so the description carries the full burden. It discloses that output is 'token-optimized' and that detailLevel+limit are supported, but does not clarify whether the operation is read-only, how errors are handled, or what happens if the path is invalid. The behavioral disclosure is minimal for a tool that likely has no side effects but still needs confirmation.

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

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

A single, front-loaded sentence that states the core purpose and key options without any redundancy. Every word contributes to the meaning.

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

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

Given six parameters and no output schema, the description is too sparse. It does not explain the 'pattern' filter, the 'responseFormat' option, or the 'includeProperties' flag, nor does it describe the shape of the returned list. An agent would need to rely heavily on the schema and may still lack context on how the tool behaves in practice.

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

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

Schema coverage is 100% with descriptions for all six parameters, so the baseline is 3. The description only mentions detailLevel and limit, adding little beyond schema. It does not explain the interplay between pattern, responseFormat, or includeProperties, which could be crucial for correct usage.

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

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

Description states a clear verb ('List') and resource ('nodes under a path'), which distinguishes it from sibling tools like get_td_node_parameters or get_td_node_errors that operate on specific nodes. The mention of 'token-optimized output' adds a unique selling point without ambiguity.

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

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

The description implies the tool is for listing nodes under a path, but does not explicitly state when to use it over alternatives. It does not mention exclusions or provide guidance on choosing between this and other node-related tools (e.g., get_td_node_parameters for detailed properties).

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

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

With no annotations provided, the description carries the burden for behavioral disclosure. It conveys that this is a capture/read operation and notes the optional downscaling, but it does not state whether the image is returned directly, written somewhere, or whether the capture triggers a cook or modifies state.

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

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

One short sentence delivers the purpose and the one optional behavior worth knowing up front. There is no redundant prose.

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

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

For a two-parameter tool with rich schema descriptions, this is mostly complete. The main gap is the absence of an output schema or any statement about the return format, which would help an agent know what to expect after invocation.

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

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

Schema description coverage is 100% and both nodePath and maxSize are fully described in the schema. The description's parenthetical about maxSize only echoes the schema rather than adding new meaning, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Capture') and resource ('current output of a TOP node'), and states the result type ('an image'). This clearly distinguishes it from the sibling tools, none of which perform image capture.

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 clearly indicates the intended use case — retrieving the visual output of a TOP node so it can be viewed directly. It doesn't explicitly name alternatives or exclusion conditions, so it falls just short of full guidance.

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

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

Annotations are absent, so the description carries the full disclosure burden. 'Update' implies mutation, but nothing is said about whether changes persist, require specific permissions, affect a live session only, or how failures are surfaced. The description does not disclose any behavioral traits or side effects needed to invoke it safely.

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

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

The description is a single, front-loaded sentence with no wasted text, which is structurally efficient. However, its brevity is also a symptom of under-specification — it earns its minimal length only by being vague, not by delivering complete information compactly.

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 state-changing tool with no annotations and no output schema, this definition is thin. It fails to describe what the nested properties object expects, what the mutation affects, or what a successful call returns. The richer sibling set (get_td_node_parameters, describe_td_tools) suggests the environment is complex enough that this gap is material.

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

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

Schema coverage is 75%, but the uncovered parameter is properties, an unconstrained key-value object that is semantically the heart of this tool. The description adds nothing about how parameter values should be formatted, whether nested values or types are supported, or how property values map to TouchDesigner node properties, leaving the most critical input undefined.

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

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

The description uses a specific verb (update) and resource (parameters of a specific node in TouchDesigner), conveying a clear purpose. It distinguishes from obvious siblings like get_td_node_parameters (read), delete_td_node (remove), and create_td_node (create) by virtue of its mutation verb, though this distinction 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?

No guidance is given on when to use this tool versus the sibling get_td_node_parameters or describe_td_tools. There is no mention of prerequisites (e.g., a running TouchDesigner instance), exclusions, or the complementary read/write relationship among the node tools. An agent must infer usage entirely from the name.

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