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

With no annotations, the description carries the full burden of disclosing behavior. It clearly states that failures are reported per item, that this is transport-level batching, and that atomic rollback is not provided. This meaningfully exceeds a bare 'batch requests' statement.

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

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

The description is compact, front-loaded with the primary purpose, and uses a clarifying contrast rather than verbose prose. Every sentence adds meaningful 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?

The description covers purpose, batching semantics, failure behavior, and parameter meaning. It doesn't describe response shape or per-item result ordering, but those may be established elsewhere; for an invocation decision, the context is solid.

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?

Despite 0% schema coverage, the description documents both parameters inline: ops as a list of {method, params} objects, and abort_on_error with its default false behavior. This is enough for an agent to construct a basic call, though item-level details remain open.

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

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

The description clearly states the action ('Run a list of router requests') and the key distinction ('ONE bridge round trip'), and it clarifies that this is batching rather than a transactional rollback. It doesn't explicitly name a sibling alternative like bridge_router_call, but the intent is unmistakable.

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 conveys when to use it: when multiple router requests need to be executed in a single round trip. It also gives an exclusion ('not a rollback transaction'), which helps prevent misuse, though it does not explicitly mention alternative single-call 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?

The side effect of opening the show is disclosed, as is the blocking wait and timeout default. With no annotations, this is decently transparent, though it does not explain failure modes or the exact shape of the returned alive status.

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

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

Two concise sentences front-load the purpose and return value, followed by a single clear parameter note. No filler or redundancy.

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

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

For a single-parameter tool, the description covers what it does, when it may open a show, the return, and the timeout default. It only omits the exact shape of the returned alive status and possible failure 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?

Even though the schema provides no description, the tool description fully documents 'timeout (float | None): Max seconds to wait (default 45)'. This adds meaningful semantics beyond the bare schema properties.

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

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

The description gives a specific action ('Open the show in TD... wait for the bridge heartbeat') and return value ('Returns alive status'). It is distinct from sibling status/state tools because it explicitly involves opening the show and waiting, not just querying state.

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

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

The description implies usage (ensure alive before proceeding) but gives no explicit guidance on when to prefer it over alternatives like bridge_status or bridge_open_show. No decision criteria or contrasting context is provided.

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

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

With no annotations, the description carries the full burden. It discloses the key behavioral trait: it refuses to launch if TD is already running unless 'force' is true. However, it does not explain what happens on success, whether it is blocking, errors thrown, or side effects like closing existing instances. It adds partial transparency but leaves significant gaps.

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 stating the purpose, followed by a clear parameter explanation. No filler, proper front-loading, and every word adds value. It is optimally concise.

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

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

For a relatively simple launch tool, the description covers the core behavior and its only parameter. However, it does not define 'resolved show', describe success/failure outcomes, or mention any prerequisites (e.g., TD installation). Given no output schema or annotations, it is acceptable but not fully complete 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?

The schema provides no description coverage (0%), just a type. The description compensates by explicitly explaining the 'force' parameter: 'Launch even if TD is running.' This fully covers the single parameter's purpose and meaning, exceeding the baseline requirement for low schema coverage.

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

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

The description clearly states the verb 'Launch', the resource 'show .toe', and the target environment 'TouchDesigner'. It uniquely identifies the tool's action among the many bridge_* siblings, which are mostly status/state/snapshot related, so a model can immediately distinguish it.

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

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

The description implies this tool is for opening a show, but it does not mention when to prefer it over alternatives or any exclusions. Among the siblings, no other tool has an overlapping purpose, so the lack of explicit alternatives is acceptable, but there is no clear 'when to use' guidance beyond the implied action.

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

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

The description discloses a key behavioral trait: it never overwrites the live file and creates a new restored.<N>.toe sibling. However, with no annotations provided, the description carries the full burden and does not mention failure behavior, whether the restored file is automatically opened, or what happens if the backup path is invalid.

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

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

The description is concise and front-loaded with the most important behavior (never overwrites the live file). The parameter explanation is brief and useful. It could be slightly more structured, but it earns its place with no wasted words.

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

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

For a single-parameter tool with no output schema and no annotations, the description covers the core action and the parameter meaning. It is missing context about what happens after restoration, how the restored.<N> numbering works, and any prerequisites or error conditions. This is adequate but not complete.

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

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

Schema description coverage is 0%, so the description must compensate. It does explain that 'backup' is an absolute path to a backup .toe file, which adds some meaning beyond the schema's bare 'Backup' title. However, it does not specify accepted extensions, whether the file must exist, or any format constraints beyond being a .toe 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?

The description states a specific verb ('Restore a backup') and resource ('into the show folder as a NEW restored.<N>.toe sibling'), and explicitly notes it never overwrites the live file. It is clear what the tool does, though it does not explicitly distinguish it from sibling bridge tools like bridge_snapshot or bridge_save_increment.

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

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

The description implies usage context: restoring a backup into the show folder as a new sibling. It does not state when to use this tool versus alternatives like bridge_snapshot or bridge_save_increment, nor does it mention prerequisites such as the show folder being open or the backup path being valid.

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 disclosure burden. It adds one meaningful behavior: destructive methods remain gated by safe mode. However, it does not mention auth requirements, invalid-method error behavior, return shape, or rate limits, leaving important dynamic behavior undisclosed.

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

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

Two concise functional sentences plus minimal parameter documentation. The 'escape hatch' and 'prefer typed tools' guidance are front-loaded, every sentence adds value, and there is no repetition or filler.

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

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

While the description covers the calling pattern and safety gating, it never touches on return format, error reporting, or what happens if the supplied method name is invalid. Even as a low-level escape hatch, an agent benefits from knowing what to expect when the router returns unknown shapes.

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

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

The schema has 0% description coverage; the description's 'e.g. node.get' adds an example format for the method name, and 'parameters as a dict' barely exceeds the schema's type information. It does not explain how to shape/populate the params dictionary properly for the target method.

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 it is a 'raw' pass-through call for 'ANY router method', emphasizes it's an escape hatch, and says the agent should prefer the typed tools. This clearly distinguishes it from the many sibling typed tools and explains what it does at the correct abstraction level.

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

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

It explicitly tells the agent to 'prefer the typed tools', making it the fallback for methods not covered by a specific sibling. 'Escape hatch' further clarifies the intended use case, giving the agent a clear directive on when to select this tool over alternatives.

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

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

There are no annotations, so the description carries the behavioral burden. It discloses a meaningful behavior: mismatches are soft warnings, not hard failures, implying a non-blocking, read-only negotiation call. It does not explicitly state side-effect-free or error semantics, but for a version surface this is sufficient.

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

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

One compact sentence conveys the return content and the key behavioral rule, with no filler. The most important information is front-loaded.

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

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

Given a zero-parameter tool and no output schema, the description covers what is returned and how mismatches are handled. It does not specify the response shape or field names, but the description is still adequate for selecting and invoking 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?

The tool has zero parameters and the schema confirms an empty properties object. There is nothing parameter-specific to explain, so the no-parameter baseline of 4 applies.

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

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

The description identifies the tool's purpose as exposing the router surface version and method count, which is specific and distinguishable from sibling bridge tools. It lacks an explicit verb like 'get' or 'retrieve,' but the intent is unambiguous for a parameterless version-info endpoint.

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 'capability negotiation; soft-warn on mismatch, never hard-lock' provides clear context for when to call this tool and how to interpret its result. It does not explicitly name alternatives or exclusion cases, which keeps it from 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?

There are no annotations, so the description itself must carry the behavioral information. It does this well by stating the operation is 'SAFE', structurally refuses to overwrite an existing file, and writes a new incrementing filename (Show.<N+1>.toe).

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

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

The description is extremely concise, front-loaded with the core behavior ('SAFE save'), then gives the file naming rule, the overwrite guarantee, the preferred usage, and the timeout parameter. No filler.

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

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

For a tool with one optional parameter, the description provides all essential context: what it does, how it names files, why it is safe, when it should be used, and the parameter's meaning/default. No output schema exists, so no missing return-value expectation.

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

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

The schema provides only a bare timeout parameter with no description, so the description adds meaning by explaining it is a wait duration in seconds and giving an effective default of 45. It could also explain what happens on timeout.

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 concrete action: write the next numbered Show.<N+1>.toe file, safely. It explicitly highlights that it refuses to overwrite existing files, which distinguishes it from a generic save or overwrite tool.

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

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

It clearly positions the tool as 'the preferred way to persist bridge edits,' giving the agent a strong usage signal. It does not explicitly describe alternatives or exclusions, so it is not a full 5, but the context is 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?

There are no annotations provided, so the description carries the full burden of disclosing behavioral traits. It gives no indication of safety, side effects, error behavior, or response format. 'Raw bridge send' implies low-level and potentially dangerous operations, but that is not elaborated.

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 brief, consisting of a single main sentence and minimal parameter descriptions. It is concise, though perhaps too terse for the complexity of the 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?

This is a low-level, potentially powerful tool with no output schema and complex nested payload. The description provides almost no context: no example usage, no explanation of supported opcodes beyond vague hints, no mention of error handling or security considerations. It is severely incomplete 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?

The schema coverage is 0%, so the description must explain parameters. It lists 'op' as 'Bridge opcode (eval, python, ...)' and 'payload' as 'Payload dict', which adds minimal meaning beyond the schema property names, but it does not explain allowed values, structure, or constraints beyond the examples.

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 calls it a 'Raw bridge send' and mentions op and payload, but does not specify what the tool actually accomplishes or how it differs from the many bridge_* siblings. It is vague and does not clarify the purpose for an agent beyond the name 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 guidance is given on when to use this tool versus alternatives like bridge_router_call or bridge_state. The only hint is 'For power users only', which is a warning, not a usage guideline. An agent cannot determine under what circumstances to select this tool.

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

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

With no annotations available, the description carries the full burden of disclosing behavior. It explicitly discloses the key safety property: 'never overwrites anything'. This is meaningful behavioral context beyond the tool name, though it does not cover storage location or backup retention.

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. The core action is front-loaded, and the safety guarantee is appended efficiently in parentheses.

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-parameter, no-output-schema backup utility, this description is complete. An agent knows what action to take, what resource is affected, and that it is non-destructive. Nothing else is 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?

The tool has zero parameters, so the baseline is 4. The description adds no parameter documentation, but none is needed. The full behavior is expressed without parameter 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 specific verb+resource pair: 'Copy the current show .toe' to a 'timestamped backup'. The non-overwrite guarantee further sharpens the action. It is clearly distinguishable from siblings like bridge_save_increment, bridge_restore, and node_snapshot.

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

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

The description implies when to use the tool: when you want a safe, timestamped backup of the current show. However, it does not explicitly mention alternatives or state when not to use it, so some routing burden falls on the agent.

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

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

There are no annotations, so the description carries the burden. 'List existing backups' clearly indicates a read-only operation and 'newest-first' describes ordering, but no other behavioral details are provided, such as whether snapshots are returned individually or as a summary.

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

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

The description is extremely concise and front-loaded: it states the action (List), the resource (existing backups), and the ordering (newest-first). No unnecessary 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 zero-parameter listing tool, the description is nearly complete. It could optionally mention whether this is limited to bridge backups vs. other snapshot types, but the purpose and behavior are sufficiently clear.

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

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

The tool has zero parameters and schema coverage is 100%, so there is no parameter ambiguity. The description's mention of 'backups' and 'newest-first' adds meaning beyond the empty schema, clarifying what is being listed.

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 ('List') and a specific resource ('existing backups'), with a clear ordering constraint ('newest-first'). It clearly distinguishes itself from sibling tools like bridge_snapshot (creating) and bridge_restore (restoring), so an agent can tell what this tool does without guessing.

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 usage context: call this whenever you need to see existing backups, sorted newest-first. However, it does not explicitly compare to bridge_snapshot or bridge_restore, so there is no direct guidance on choosing this over related bridge tools.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It reveals the possible return states, which is helpful, but it does not state whether the call is read-only, whether it can fail, what happens on error, or any side effects. For a probe-like tool, it likely has no side effects, but this is not explicitly confirmed. The lack of any safety or side-effect information leaves the agent guessing.

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

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

The description is a single concise sentence with no wasted words. It front-loads the essential information (the possible states). While it is brief, it is not under-specified to the point of being cryptic; it communicates the core function effectively. The brevity is appropriate for a tool with no parameters and a simple return 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?

The tool is simple (no params, no output schema), but the description still leaves gaps. It does not explain what 'TD' refers to, nor does it describe the return format (e.g., a string, enum, or JSON). It also does not mention any error conditions or prerequisites. Given the lack of annotations and output schema, the description should provide more context about the intended use and behavior, which it does not.

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

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

The tool has zero parameters, and the schema confirms this. According to the baseline, 0 parameters yields a score of 4. There is nothing for the description to add about parameters, and it does not attempt to describe any, so it fully satisfies the semantic requirement.

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 it is a 'TD three-state probe' and lists the possible states (ok | starting | down | off). It is not a tautology and gives a specific resource (bridge state) and action (probe), but it does not explicitly state what the tool does beyond returning one of these values. It is somewhat vague, as 'TD' is not explained, and the exact return format is not described. It does not distinguish itself from sibling tools like bridge_status or bridge_snapshot.

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 siblings. No context is given about the situation where this probe is appropriate, and no alternatives are mentioned. The description implies a read-only status check, but it never states conditions for use or exclusions.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. The description lists the output fields (alive, age, project, build) but does not disclose whether the tool performs any side effects (it appears read-only, but that is not stated), whether it can block or timeout (if the bridge is down, does it hang or return error?), or what the actual return format is. It also does not mention any error handling or connection requirements. For a status tool that might be used in health checks, this transparency is insufficient.

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

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

The description is concise and front-loaded: 'Bridge heartbeat state' immediately conveys the essence, followed by a list of key fields. It is a single sentence without fluff. It could be slightly improved by adding a period and perhaps more detail, but it is efficient and structurally sound for its 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?

The tool has no parameters, no output schema, and no annotations. The description lists the output fields but does not explain their types (e.g., 'alive' likely boolean, 'age' integer) or the response format (JSON? text?). An agent calling this tool would need to know the output structure to use it effectively. Also, given the complexity of sibling tools (many bridge_* tools), the description does not clarify how this status tool fits into workflows, such as when to use it before calling bridge_send or bridge_ensure_alive. The description is too minimal for a complete picture.

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

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

The tool has zero parameters, and the schema coverage is 100% (the schema is empty, so all parameters are documented). With no parameters, the description does not need to explain parameter behavior. The description adds value by clarifying the output fields, which is useful for interpretation, but since there are no inputs, the parameter semantics dimension is mostly satisfied by the absence of parameters, which the description confirms by not mentioning any.

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

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

The description clearly states the tool's purpose: to provide the bridge heartbeat state, including specific fields like alive status, age in seconds, project, and build. This distinguishes it from the sibling tool 'bridge_state' which likely returns a general state, but the description does not explicitly differentiate it. The verb 'heartbeat state' is specific enough to convey a health-check function, making it a clear, though not deeply differentiated, purpose.

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

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

The description implies usage for checking bridge liveness via the 'alive' field and age, but it does not explicitly state when to use this tool versus alternatives like 'bridge_state' or 'bridge_ensure_alive'. There is no guidance on when to check status versus when to take action, and no mention of pre-conditions or typical scenarios. The context signal of zero parameters suggests a simple call, but the lack of explicit usage context and alternatives is a gap.

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

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

No annotations are provided, so the description carries full responsibility for disclosing behavior. It only states the action (wiring ops) but does not mention side effects (e.g., overwriting existing connections), error conditions (e.g., invalid paths), or whether the operation is reversible. For a create operation, this lack of behavioral detail leaves the agent guessing about consequences.

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

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

The description is compact and well-structured. It leads with a one-sentence purpose, then lists each parameter with a brief explanation. There is no redundant or filler content, and the critical purpose is front-loaded. Every sentence earns its place.

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

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

While parameter semantics are fully covered, the description omits usage context such as when to use conn_create versus connection_create, what happens on success (no output schema exists), and any prerequisites like ensuring nodes exist. These gaps are notable given the tool's simplicity and the presence of a similarly named sibling, making it incomplete for fully informed 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 schema has 0% description coverage, so the description is the sole source of parameter meaning. It explicitly defines each parameter: fromPath as source operator path, toPath as destination operator path, fromOutput as source output index, and toInput as destination input index, with defaults. This fully compensates for the schema's lack of descriptions.

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

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

The description opens with a clear, specific verb and resource: 'Wire two ops together (output -> input).' This unambiguously states the tool's function and differentiates it from sibling tools like conn_delete or conn_get, which are clearly different operations. The phrasing is direct and action-oriented.

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

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

The description gives no guidance on when to use this tool versus alternatives. Sibling tools include both conn_create and connection_create, and there is no distinction made between them, nor any mention of prerequisites or typical scenarios. An agent would have to infer usage from the name alone, which is insufficient.

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

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

The description only states the basic action of disconnecting an input/output; it does not disclose effects on the node graph, whether both indices can be omitted, what happens if no connection exists, or any destructive side effects. With no annotations providing safety or mutability context, 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 core purpose is front-loaded in a single sentence, and the parameter list is compact. Some inline type annotations are redundant with schema information, but there is minimal waste overall.

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 definition lacks important behavioral details for a mutating operation: what happens if both inputIndex and outputIndex are omitted, whether the node is modified permanently, and what the result/return value is. No annotations or output schema compensate. An agent is left to infer critical execution semantics.

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

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

Schema descriptions are absent, so the tool description is the only documentation. It explains `path` as the operator path and says inputIndex/outputIndex select which input/output to disconnect, but the wording is somewhat circular and gives no guidance on defaults or combinations.

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

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

The description clearly states the action ('Disconnect') and the object ('an input and/or output of a node'), which is specific and distinct from sibling tools like conn_create and conn_get. The verb-resource pairing makes the tool's purpose immediately understandable.

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

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

The description gives no guidance on when to use this tool versus related tools such as connection_delete, conn_create, or conn_get. There is no mention of prerequisites, exclusions, or alternatives, leaving the agent to 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.

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

Since no annotations are provided, the description must disclose behavioral traits. It does state it is an alias of conn_create, which implies creating a connection is a mutating operationholistically. However, it does not explain any side effects, such as whether existing connections are affected, whether the connection replaces an existing one or duplicates, or whether it validates the paths. The parameter documentation is a copy of the schema and adds no extra behavioral context beyond the alias statement.

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 brief and front-loaded: the alias statement comes first, followed by parameter descriptions. There is no fluff. However, the parameter documentation is formatted as a list of Python types with descriptions, which is functional but not perfectly structured. It earns a high conciseness score for efficiency, but loses a point for the slightly awkward formatting and redundancy 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?

The tool is simple (two required string parameters, two optional integers), but the description is still shallow. It doesn't explain the relationship to the graph or the purpose of creating a connection, nor does it provide usage examples or edge cases. Sibling tools like node_create are also ambiguous, but for a mutating tool, an agent would benefit from knowing what success looks like (no output schema) and potential errors. The description is not complete enough for an agent to use it with 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 compensate. It lists each parameter with a brief explanation: 'Source operator path', 'Destination operator path', 'Source output index (default 0)', and 'Destination input index (default 0)'. This is minimal but useful for understanding what each parameter means, though it does not clarify the syntax of paths or the meaning of the indexes (e.g., are they zero-based output ports?). The description does add some value beyond the schema types, but not enough for complete clarity.

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

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

The description identifies the tool as an alias of conn_create, which creates a connection between an output of one operator and an input of another in a node graph. It clearly states the verb 'create' and the resource 'connection,' and the alias relationship helps distinguish it from the similarly named 'conn_create' sibling. However, it does not explicitly state what a connection is or that it operates on operator paths, though the parameter names convey this.

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 other connection-related siblings such as conn_create, conn_delete, conn_get, connection_delete, or connection_get. It merely says it's an alias of conn_create, which implies they are interchangeable, but it doesn't explain why an agent might prefer this alias over conn_create (e.g., MCP compatibility). No exclusions or context are provided.

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

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

No annotations are provided, so the description must disclose behavioral details itself. It states the core action, disconnecting inputs/outputs, but omits side effects, reversibility, error behavior, whether all connections are removed when indices are omitted, and what the tool returns.

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

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

The description is short and contains no filler. It front-loads the alias and then lists the parameters in a scannable format. The brevity is good, though it comes at the cost of missing 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 deletion tool with no annotations, no output schema, and three parameters, the description is too sparse. It does not explain how the parameters combine, what happens in default cases, what errors may occur, or what the result of the deletion is. An agent would struggle to use this correctly without external knowledge of TouchDesigner's conn.delete API.

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 barely adds meaning: path is called an 'Operator path' and the indices are linked to disconnecting inputs/outputs, but it lacks path format, indexing convention, interaction between the two optional indices, and None behavior.

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

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

The description conveys that this tool deletes or disconnects connections on an operator path via the phrases 'Disconnect this input' and 'Disconnect this output'. However, it relies on the cryptic 'Alias of conn.delete' and does not clearly distinguish itself from the sibling tool conn_delete.

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 conn_delete or connection_create/get. The description does not explain when to provide path alone versus inputIndex/outputIndex, nor does it mention prerequisites such as the connection needing to exist.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it discloses almost nothing. It does not state whether the operation is read-only, what happens if the path does not exist, or any side effects. The description is essentially a shell that provides no behavioral information beyond the tool's name.

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

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

The description is extremely short, but this is under-specification rather than conciseness. The entire content is one sentence that offers no genuine explanation. It is not well-structured because it fails to communicate key information; the word count is minimal but not every word earns its place given that none of them provide substantive help.

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

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

Given that there is no output schema and the operation is a 'get' (presumably retrieving something), the description is completely inadequate. It does not explain what is returned, how the path maps to a connection, or any edge cases. The agent is left with no information to correctly invoke the tool or interpret results.

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

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

The schema has only one parameter ('path') but includes no description for it and the schema_description_coverage is 0%. The description mentions 'path (<class 'str'>): Operator path.' which is just repeating the type and adding 'Operator path' – a cryptic phrase that does not clarify what the path refers to. It adds too little meaning to compensate for the lack of schema descriptions.

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

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

The description is just 'Alias of conn.get.' with no elaboration on what the tool does. 'conn.get' is an undefined term and 'Alias of' is tautological; an agent cannot discern the actual purpose or the type of resource being retrieved. The name 'connection_get' suggests it fetches a connection, but the description does not confirm this or explain what 'conn' refers to.

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

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

There is no guidance on when to use this tool versus alternatives. Sibling tools like 'conn_create', 'conn_delete', and 'connection_create' exist, but the description does not specify when 'connection_get' is the right choice or contrast it with similar tools. No prerequisites or usage context 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?

The tool is described as read-only, which implies a non-destructive operation)Skip. However, with no annotations and no output schema, the description doesn't reveal what is returned (counts, objects, paths) or how invalid paths are handled.

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

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

Two short sentences; no fluff, redundant qualifiers, or boilerplate. The parameter note is compact and scannable.

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

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

Basic purpose and parameter are covered, sufficient for a simple getter, but the absence of behavior details (return shape, path format, error cases) and no annotations leaves gaps for an agent needing to use results correctly.

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

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

The only parameter is described as 'Operator path', adding some meaning to the bare string schema, but no format, example, or path convention 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 names a specific verb and resource: 'Read all input/output connections of a node.' This is reasonably clear, but it does not explicitly distinguish this tool from siblings like connection_get or conn_create, so it stops short of full clarity.

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 sibling tools such as connection_get/conn_delete, and no stated constraints or use cases beyond the literal action.

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 does mention that values are 'uniformly downsampled' and that max_samples has a default of 1024, which is useful, but it says nothing about return format, error behavior, or what happens when the path is invalid or when multiple channels exist. This is a significant gap for a tool with no structured behavioral 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 extremely concise: a one-line core statement followed by parameter descriptions. The key scoping phrase 'uniformly downsampled' is front-loaded. It earns its place, though the parameter descriptions embedded in the text could be formatted more cleanly if they were part of the schema. No redundant or filler content.

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

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

The tool is simple (2 parameters, no output schema, no nested objects), and the description covers the essential purpose and parameters. However, the absence of an output schema means the agent has no idea what the return shape is (e.g., typed arrays, sample counts, timestamps), and no mention is made of typical usage context or limitations. For such a minimal tool, this is adequate but not complete.

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

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

Schema description coverage is 0%, but the description explicitly documents both parameters: path as a CHOP operator path, and max_samples as max samples per channel with a default of 1024. This compensates well for the bare schema. However, there is a discrepancy: the schema default is null while the description states 1024, which creates ambiguity and prevents a perfect score.

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

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

The description states a specific verb ('Read') and a specific resource ('CHOP channel values'), which clearly indicates what the tool does. It is distinguished from siblings like data_top, data_sop, and data_dat by naming the CHOP data type, but it does not explicitly contrast itself with those alternatives. Slightly more explicit differentiation would make this a 5.

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

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

There is no guidance on when to use this tool versus sibling data tools (data_top, data_sop, data_dat), nor any mention of prerequisites, exclusions, or alternative selection criteria. The description only states the operation, leaving the agent to infer usage from the tool name and resource type.

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. "Read" implies a non-mutating operation, and the row range parameters with "Last table row, exclusive" add useful behavioral detail. However, the description omits return format, error behavior, and what happens when row_start or row_end are null. Additionally, the description says row_start defaults to 0 while the schema sets its default to null, which creates ambiguity.

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

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

The description is compact and well-structured: one purpose sentence followed by one line per parameter. There is no fluff, and the most important information is front-loaded.

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

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

For a simple read tool with three parameters, the description is mostly adequate: it states the purpose and documents all parameters. But because there is no output schema and no annotations, the missing return format, ambiguous null handling, and lack of sibling guidance leave noticeable gaps for an agent deciding how to invoke and interpret the result.

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

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

Schema description coverage is 0%, so the description must compensate, and it largely does: it documents all three parameters with types and meanings, including the useful "exclusive" qualifier for row_end. The main flaw is the row_start default mismatch with the schema and the lack of a stated default for row_end.

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

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

The description begins with a clear verb and resource: "Read text or table DAT content." It identifies the tool as a DAT-reading operation and names the target with "DAT operator path." It does not explicitly contrast itself with sibling tools like data_dat_write or data_chop, but the resource class (DAT) is enough to distinguish it in most cases.

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 data_dat_write for writing, nor does it explain that other data_* tools target different operator types. An agent must infer usage solely from the tool name and the minimal purpose sentence.

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

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

With no annotations provided, the description carries the full burden. It does disclose the mutating nature of the tool, including 'Replace full text content', 'Append a row', and 'Clear before writing'. However, it does not mention side effects, permissions, return values, or behavior when multiple parameters are set together.

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

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

The description is compact and structured as a bullet-like list with no filler. Each parameter gets a short, purposeful explanation, and the opening line summarizes the three core actions efficiently.

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

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

The description covers all parameters and the main behaviors, but it leaves out important usage context such as whether `text` and `appendRow` are mutually exclusive, what `clear` applies to, and what the tool returns after writing. Since there is no output schema, this missing context reduces 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?

Schema description coverage is 0%, so the description must compensate. It does so by explaining `path` as a DAT operator path, `text` as replacement content, `appendRow` as appending a table row, and `clear` as clearing before writing. This adds meaningful semantics 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?

The description states the tool writes to a DAT, with three modes: replacing text, appending a row, and clearing. This is specific enough to identify the operation, though the verb 'write' is generic and it does not explicitly distinguish this from the sibling `data_dat` tool.

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

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

The description explains what operations are available but gives no guidance on when to use this tool versus alternatives like `data_dat`, nor any conditions or prerequisites. There are no exclusions or decision rules for choosing between text replacement, append, and clear.

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

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

With no annotations, the description carries the behavioral burden. It discloses the sampling behavior, threshold semantics, and the optional full-frame numpyArray() read. It does not explicitly state read-only/unmodified effect, but for a pure sampling/statistics tool that behavior is logically inherent.

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 tight, front-loaded with the core purpose, and the parameter list is compact and readable. It is not excessively long, although the appended parameter documentation could be formatted more cleanly as a separate section.

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?

Output schema is absent, but the description names the expected luma stats and flags, which is sufficient for an agent to infer result shape. It could be more complete by describing the exact output format or a return key example, but the essential semantics are covered.

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 provides meaning for every parameter: path, grid (samples per axis), numpy (full-frame read), dark_below threshold, and solid_std threshold, including sensible defaults. This is far beyond the schema and gives an agent everything needed to fill parameters correctly.

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 clearly states it computes luma statistics (mean/min/max/std) of a TOP with dark, solid, and clipped flags. The phrase 'is the output actually black?' distinctly identifies a concrete use case and distinguishes this pixel-sampling tool from sibling data_* 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?

Provides clear contextual usage: it is described as the 'black output verifier', which tells the agent when to invoke it. It does not explicitly name alternatives or give exclusion criteria, but the use case is explicit enough for most callers.

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 disclosure burden, and the only behavioral implication is a read operation inferred from 'point count/positions and bounds.' It discloses nothing about side effects, read-only guarantees, behavior on an invalid or non-geometry path, or performance implications on large point counts.

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 four words plus a parameter line saying 'path (<class 'str'>): SOP operator path,' which largely restates the schema's type and title. This is under-specification rather than conciseness; the structure does not earn its brevity because the summary sentence carries almost no functional 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?

With no output schema and no annotations, the description should carry the burden of explaining return values and invocation requirements. It hints at the return payload (point count, positions, bounds) and documents the sole required parameter, but leaves unstated what a valid path looks like, what happens on failure, and whether the call is a safe read 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?

The schema itself has 0% description coverage — the parameter is only a string titled 'Path.' The tool description adds the essential clarification that the string is an 'SOP operator path,' which is genuine added meaning beyond the schema. However, it omits path format details (absolute vs relative, separators, wildcards) and provides no example value.

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

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

The description is a verbless noun phrase, 'SOP point count/positions and bounds,' which identifies the subject matter but never states that the tool retrieves or returns anything. It hints at the resource type (SOP, contrasting with data_chop/data_top/data_dat) but leaves the actual operation to inference, and the fragment could even be misread as a setter given that data_dat_write exists as a sibling.

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

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

No guidance is given for when to use this tool versus alternatives. It does not distinguish itself from the sibling family data_chop/data_top/data_dat/data_pixel_sample or from node_get/par_get, so an agent must guess which data-retrieval tool fits. No exclusions, prerequisites, or context 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 provided, the description carries the full burden. It does not disclose that the tool likely performs a read operation, nor does it mention any side effects, permissions, or performance considerations. The optional pixel capture could be expensive, but that is not mentioned.

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 line plus parameter list. It is not overly verbose, but the initial line could be more informative. The parameter list is structured and easy to read. It is concise but lacks completeness.

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 4-parameter tool with no annotations and no output schema, the description is insufficient. It does not explain what 'resolution' means in output, how the pixel capture works, or what the return format is. It fails to address potential edge cases (e.g., invalid path, what happens if pixels is false).

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

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

The description lists each parameter with a brief comment (e.g., 'TOP operator path', 'Capture pixels as base64 PNG', 'Downscale if wider'). This adds some meaning beyond the schema, although the schema doesn't provide descriptions. However, the parameter names and comments are fairly self-evident, so the added value is moderate. With 0% schema coverage, the description must compensate, and it partially does.

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 'TOP resolution, optionally base64 PNG pixel capture' is somewhat vague: it doesn't clearly state that it retrieves the resolution of a TOP and optionally captures pixel data. It could be interpreted as a resolution operation or something else. There is no distinction from siblings like data_sop or data_dat.

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 siblings such as data_sop or data_pixel_sample. No context is provided about typical use cases or limitations. The description gives no hints about when to prefer this tool over others.

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 burden. 'Distribute nodes' conveys that positions change, and it states axis and spacing defaults, but it does not address reversibility, side effects on existing positions, or whether the operation is aligned to a grid/sequence. It is moderately transparent but leaves some behavioral gaps.

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 text is a single focused sentence followed by a compact parameter list. The action and defaults are front-loaded inhering the natural language sentence; no redundant 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?

Provides enough to invoke the tool with paths and defaults, but does not state what happens when start_x/start_y are omitted, whether existing positions are overwritten, or what the tool returns. These are not critical gaps for a simple layout operation, but they leave room for agent uncertainty.

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

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

The description adds meaning to every parameter: paths are the nodes to distribute, axis has a default between horizontal/vertical, spacing has a default of 200, and start_x/start_y define the origin. This fully complements the input schema.

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

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

The description states a specific verb and resource: 'Distribute nodes along a horizontal or vertical axis.' This clearly identifies what the tool does. However, it does not explicitly distinguish itself from the closely related sibling layout_set_position, leaving some differentiation to 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 provides no guidance on when to use this tool versus alternatives such as layout_set_position, nor does it mention prerequisites (e.g., node selection, current layout state). An agent must infer the intended invocation context from the name and sibling list.

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

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

There are no annotations, so the description carries the burden of behavioral disclosure. It says positions are set, but does not mention coordinate units, whether existing positions are overwritten, side effects on connected layout, or whether the operation is reversible.

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

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

The description is very short and front-loaded with the verb and object. It wastes no words)Skip, though it embeds parameter documentation inline instead of relying on the schema.

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

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

For a mutating layout tool, the description lacks essential context: coordinate format/units, how node paths are resolved, return behavior, and side effects. The agent knows what to change but not enough to reliably construct valid arguments.

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 JSON schema provides no property descriptions and the items type is empty, so the description's 'nodes (list[typing.Any]): [{path, x, y}, ...]' is the only meaningful specification. It gives the required object shape, though it leaves path, x, and y semantics vague.

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

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

The description clearly states the action (

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

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

No guidance is given about when to use this tool versus siblings such as layout_align, or about prerequisites like node existence. The description only states what it does, not how an agent should decide to invoke it.

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

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

With no annotations, the description must carry disclosure weight. It explains what is scanned and detected, but does not state whether the operation is read-only, what the returned 'truth' looks like, or whether any state is changed; the 'measure' prefix only weakly implies safety.

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

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

Two short sentences carry the purpose and the parameter semantics with no filler. The core behavior is front-loaded before the parameter detail.

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

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

The tool has no output schema and no annotations, so the missing return shape, effect on state, and error behavior are meaningful gaps. The single parameter is well covered, but the description leaves an agent unsure what calling it will actually return or change.

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

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

Even though schema coverage is 0%, the description fully documents the only parameter: path is a string or null, it is the root container to scan, and its default is '/'. This is exactly the semantic detail an agent needs.

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

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

The description states a concrete function: it reports per-device topology truth (Bypass/Src/Srcpath) and detects chain orphans for chained COMPs, with a root path scope. This distinguishes it from generic measure siblings, though the term 'truth' is jargon and no explicit verb appears outside 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 use case is implied by the first line: use it when you need per-device chain topology/orphan detection in a TouchDesigner COMP container. However, it never says when not to use it or how it contrasts with measure_verify, measure_gpu, or measure_cooktimes.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It does explain the output ordering and scoping semantics ('Parent whose children are measured', 'Return only the N most expensive'), but it leaves the return shape undefined, neither confirms the operation is non-mutating/read-only nor defines what 'device' means.

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

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

The definition is compact and front-loaded: the first sentence conveys the core behavior and purpose, followed by a minimal, scannable parameter list. Every sentence adds necessary information with no filler.

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

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

For a three-parameter measurement tool with no output schema and no annotations, the description covers the key inputs and output ordering, which is a solid baseline. However, it leaves gaps around the exact return format, whether path and paths are mutually exclusive, and the precise meaning of 'device' in the output.

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

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

Schema description coverage is 0%, so the description must fully document the parameters, and it does: 'paths' identifies operators to measure, 'path' selects a parent whose children are measured, and 'top' limits results to the N most expensive. This adds real meaning beyond the bare JSON schema, though it does not clarify the relationship between 'paths' and '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?

The description names a specific metric ('per-operator cook cost (ms)'), a sorting behavior ('most-expensive first'), and a practical diagnostic goal ('which device is eating the frame'). It is clear about what the tool measures, though it does not explicitly contrast itself with sibling measure_* tools such as measure_gpu or measure_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?

The description gives no explicit guidance on when to choose measure_cooktimes over the sibling measurement tools, nor does it explain whether 'paths' and 'path' should be used exclusively or how they interact. The intended use is only implied by 'per-operator' rather than stated as a selection 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?

No annotations are provided, and the description does not disclose whether the tool is read-only, what side effects it might have, or what the returned value represents. It does not add any behavioral context beyond the name.

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

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

The description is concise but not written as a sentence; it is a comma-separated list of keywords. It does not front-load a concrete meaning and 'every word should earn its place' is not satisfied because the terms are ambiguous.

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 0-parameter tool with no output schema, the description must clarify what the tool returns or measures. It fails to explain any output format, default behavior, or even its relationship to sibling measurement 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?

With zero parameters, the baseline is 4. The schema already covers the parameter set (empty), and the description does not need to explain inputs. It also does not conflict with 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 'FPS, realtime flag, cook rate, throttle queue' is a list of terms rather than a clear verb+resource statement. It implies measurement of FPS but does not explicitly state the tool's purpose, and it fails to differentiate from sibling tools like measure_gpu or measure_cooktimes.

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

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

No guidance is given on when to use this tool versus alternatives. The description is a bare list with no mention of context, prerequisites, or exclusions.

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

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

No annotations are present, so the description must disclose behavioral details. It does explain that require_render (default true) will error when TD is not rendering, which is a concrete behavior. It does not clarify whether this is a read-only operation, what output shape is produced, or whether any side effects exist, leaving some behavioral gap.

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

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

The description is two sentences of prose: the first conveys the tool's output and core purpose, the second addresses the sole parameter. There is no filler, no repetition of the tool name, and the most relevant information that appears first.

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

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

For a tool with one optional parameter and no output schema, the description covers what the tool exports (GPU health and render status) and the parameter's semantic. It doesn't describe the return format, but that information is likely not required for a simple diagnostic. The 'detector' phrase gives extra context beyond the technical description.

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

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

The schema provides no descriptions and only marks the parameter as an optional 'boolean or null' with a null default. The description adds meaning by stating that require_render controls the error behavior when TD is not rendering and clarifies the default effective value (true), which the agent could not deduce from the schema alone.

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

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

The description communicates that the tool measures GPU utilization/VRAM and whether TD is actually rendering, encapsulated as a 'looks healthy but isn't' detector. This distinguishes it from other measure_* siblings, but it lacks an explicit verb like 'measure' or 'get'; the tool name supplies the action.

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 'the looks healthy but isn't detector' and the require_render parameter imply when it should be used: when other metrics suggest system health but real rendering may be failing. However, no explicit alternatives are named, and no clear 'use this instead of X' or 'don't use this when Y' conditions are provided, leaving the agent to infer 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?

The description reveals that the tool evaluates an expression and returns rtt_ms plus a live TD value, which is useful behavioral information. However, with no annotations, it does not explicitly state whether this is read-only, whether the expression can have side effects, or what happens on invalid expressions.

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 behavior stated in the first sentence. The term 'live TD value' is slightly ambiguous but the overall structure is efficient.

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

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

The description covers the main return values and the parameter, but lacks guidance on side effects, failure modes, or how this tool relates to diagnostic siblings. Given no annotations and no output schema, more context would be needed for confident invocation.

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

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

The schema has 0% description coverage, but the description adds the meaning of the 'expr' parameter and its default value (absTime.seconds). It could be clearer about the evaluation context, but it provides the essential 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 identifies the tool's purpose as a round-trip canary over the file bridge, returning rtt_ms and a live TD value. This is specific enough to distinguish it from bridge_status and system_ping, though the jargon ('canary', 'file bridge') is not unpacked.

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

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

The description implies a diagnostic/latency-check context but gives no explicit guidance on when to choose this tool over siblings like system_ping, bridge_status, or measure_fps. No alternatives or when-not conditions 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 discloses the main behaviors: clearing the accumulated log, forcing a cook, and re-reading errors. It also explains the force_cook option meaning, which is useful. It could mention return shape or permissions, but these are minor for this operation.

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

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

The description is compact and front-loaded with the core action, then gives a useful interpretation rule, then documents parameters. It is slightly redundant because the opening sentence already says force a cook and the force_cook line repeats it, but there is 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?

For a two-parameter mutation tool with no output schema and no annotations, this is reasonably complete. It tells the agent what will happen, what the optional parameter controls, and how to interpret one-off versus recurring errors. Explicit return-value or confirmation behavior would be the only notable 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?

The description adds meaning to both parameters beyond the bare schema: path is the operator path, and force_cook controls the post-clear cook(force=True) behavior. There is a minor mismatch where the prose says the default is true while the schema says null, but the description still meaningfully compensates for the 0% schema coverage.

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

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

The description states a specific action: clear a node's accumulated script-error log, then force a cook and re-read. This makes it clearly distinguishable from sibling read tools like node_errors and node_errors_deep.

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 recurring-vs-one-off explanation provides a concrete decision heuristic: recurring errors indicate a live problem, while one-off hits are stale. It does not name alternatives such as node_errors explicitly, so it is not a perfect 5, but the context is otherwise clear.

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 mentions that TD assigns the name if omitted, which is a useful detail, but it does not disclose whether the copy is shallow or deep, whether it overwrites existing destinations, what permissions are required, or any safety considerations for this mutation 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 tightly structured: a one-sentence operation statement followed by a concise parameter list. Every sentence carries useful information, and there is no repetition of schema data or filler text.

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 and the description gives enough to call it with the required parameters. However, with no output schema and no annotations, it omits return behavior, error conditions, and copy semantics (e.g., deep vs shallow, name conflict handling), which an agent might need to use it confidently in context.

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

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

Schema description coverage is 0%, yet the description documents all three parameters with concrete semantics: sourcePath as the path of the operator to copy, destParentPath as the destination COMP path, and name with its default behavior. This fully compensates for the schema's bare titles.

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, 'Copy a node into a destination parent,' states a specific verb (copy), a resource (node), and the destination context. This clearly distinguishes node_copy from siblings like node_create (new node), node_rename, and node_get, even without naming them.

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

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

The description provides no guidance on when to use this tool versus alternatives. It implies a copying use case from the name and parameters, but there are no explicit conditions, exclusions, or mentions of sibling tools, leaving selection entirely 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 of behavioral disclosure. It does mention that the operator is auto-placed to the right of siblings, which is useful behavioral context. However, it does not describe side effects, error behavior, or whether the new operator is returned, so it leaves some behavioral ambiguity.

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

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

The description is compact and instantly readable: one sentence of purpose, one behavioral note, then single-line parameter explanations. No filler or redundant restating of the schema.

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

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

For a simple create operation, the essential param semantics and auto-placement are present. Yet with no annotations and no output schema, an agent would still be missing failure semantics and what the return value contains. It is adequate but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate fully. It adds concrete meaning to each parameter: parentPath is the full path of the parent COMP, type is the operator type string, and name is optional with TD-assigned fallback. These are non-redundant and directly usable.

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

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

The description opens with a specific verb and resource: 'Create an operator in a parent COMP (e.g. 'noiseCHOP')'. This clearly distinguishes node_create from siblings like node_copy, node_find, and conn_create. The auto-placement note adds useful scope 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 does not state when to prefer this tool over alternatives such as node_copy or node_find, nor does it mention prerequisites like the parent COMP needing to exist. Usage is only implied by the purpose statement, with no explicit when/when-not guidance.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It implies a read-only operation but does not state side effects, permissions, error handling for invalid paths, or the shape of the response. This is a minimal disclosure for a tool that could still have unexpected behavior.

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

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

The description is extremely concise: one line for purpose and two lines for parameters. Every sentence earns its place, and the purpose is front-loaded.

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

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

For a simple 2-parameter tool with no output schema, the description covers the purpose and parameters adequately. However, it omits usage context (when to choose this vs node_errors_deep) and does not describe return values, which could be relevant for an agent. This is a moderate 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. It does explain both parameters: path (full path of the operator) and includeChildren (bool or None, with meaning 'Also collect child errors'). This adds meaning beyond the schema's bare type declarations.

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 retrieves errors/warnings for a node, with an optional includeChildren flag. It specifies the resource (node) and the action (retrieve errors), but does not differentiate from the sibling node_errors_deep, which likely performs a similar but deeper operation.

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

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

No guidance is given on when to use this tool versus node_errors_deep or other error-related tools. The description implies a simple read but provides no explicit when/when-not conditions or alternatives.

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

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

No annotations exist, so the description carries the behavioral burden. It discloses traversal scope, result filtering ('Only nodes with a problem are returned'), and the defaults for path, max_depth, and max_nodes. It does not explicitly state that the tool is read-only or describe failure behavior, but the core behavior is clear and constrained.

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

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

The description is compact and well-structured: a one-sentence purpose up front followed by a lean parameter list. Every sentence adds information, with no filler or redundancy.

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

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

With no output schema or annotations, the description explains the traversal, limits, and result filtering, which are the core essentials for invoking the tool. It does not detail the exact structure of the returned node data or error messages, nor edge-case behavior for invalid paths. These are minor gaps for a straightforward query tool.

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

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

The schema has 0% coverage, and the description compensates fully by explaining all three parameters with types, defaults, and semantic meaning: path (root), max_depth (recursion limit), and max_nodes (visit cap). This is exactly the kind of semantic enrichment the schema lacks.

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

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

The description clearly states the tool's function: 'Walk a whole subtree; report every node with cook errors, warnings, parameter-expression errors or script errors.' It uses strong verbs and identifies the exact resource and scope. The emphasis on 'whole subtree' distinguishes it from the shallow sibling node_errors.

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

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

The description implies usage for deep recursive error scanning but provides no explicit guidance on when to choose this tool over alternatives like node_errors. No exclusions, prerequisites, or use-case context are given; the agent must infer from the name and description.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It does reveal recursion and useful defaults (path '/', depth 5) as well as matching semantics (case-insensitive substring, exact type). However, it does not disclose whether the search is read-only, what happens on invalid paths, or how results are returned.

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 opens with a clear one-sentence purpose and then uses a compact parameter list. Every line carries semantic value, with no filler or repetition.

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

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

The parameter documentation is strong, but there is no output schema and no description of the return value, result format, empty-result behavior, or how multiple filters interact. An agent can call the tool, but cannot predict what it will receive back.

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

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

Schema description coverage is 0%, but the description fully compensates by explaining every parameter: path default '/', name as case-insensitive substring, type as exact case-insensitive, family with examples, and depth as max recursion with default 5. This adds substantial meaning beyond the bare input schema.

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

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

The description states a specific action ('Search for nodes') with clear matching criteria (name/type/family) and recursive scope. It distinguishes itself from node_get and node_create, but it does not explicitly contrast with the closely related node_list, so it is not 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 explicit guidance on when to use node_find versus alternatives like node_list or node_get. The filtering semantics imply it is for locating nodes by criteria, but the description never states when this tool should be preferred or when another sibling should be used.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool returns metadata but does not disclose whether this is a read-only operation, whether it errors on nonexistent paths, what the response structure looks like, or any side effects. For a retrieval tool this is a moderate gap, but the lack of any behavioral context beyond 'returns metadata' keeps the score low.

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

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

The description is very short and front-loads the core purpose in the first sentence. The parameter explanation is minimal but relevant. It earns a 4 because it is efficient, though it could be slightly more structured by separating the parameter note more clearly.

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

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

Given the tool has no annotations, no output schema, and a single parameter with 0% schema coverage, the description is too thin to fully support correct invocation. It does not clarify the path format, return value shape, or error behavior, which are essential for an agent to use this tool confidently. The presence of many sibling tools also increases the need for clearer differentiation.

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

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

Schema description coverage is 0%, so the description must compensate for the schema's lack of parameter documentation. The description does mention 'path' and its meaning ('Full path of the operator'), which adds some value beyond the bare schema property name. However, it does not explain path format, whether it is a file path or node path, or any constraints, leaving significant ambiguity.

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

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

The description states a specific verb ('Full metadata for one operator') and resource ('operator'), which clearly identifies what the tool returns. It does not explicitly differentiate from sibling tools like node_list or node_find, but the phrase 'Full metadata for one operator' implies a single-entity retrieval distinct from listing or searching.

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

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

No guidance is provided on when to use this tool versus alternatives such as node_list, node_find, or par_get. The description implies usage for retrieving metadata for a single operator, but it does not state exclusions or conditions that would route an agent to a sibling tool.

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

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

No annotations are provided, so the description must carry the behavioral load. 'List' clearly implies a read-only operation, and parameter semantics are stated, but it does not disclose what happens for invalid paths, ordering, or whether depth None means unbounded recursion. This is a moderate gap for a simple list operation.

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

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

The description is compact and front-loaded, with one clear purpose sentence followed by a concise parameter list. Every line adds useful information without repetition or filler.

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

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

For a tool with only three optional parameters and no output schema, the description covers the core invocation requirements well. Minor omissions like depth default and error behavior prevent a perfect score, but nothing essential is missing for basic usage.

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

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

Schema description coverage is 0%, so the description must compensate for the bare schema. It adds meaningful detail for all three parameters: path default, family filter meaning, and depth semantics with an example unit ('1 = direct children'). It does not specify depth's default or full behavior, so it is not perfect.

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 clear verb and resource: 'List children of a container.' The optional family filter and parameter hints make the operation specific. This is easily distinguished from sibling tools like node_get and node_find by its focus on container children.

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

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

The description establishes clear context: use it to list children under a path with optional family and depth filtering. It does not explicitly name alternatives or when not to use this tool, but the operation is obvious enough that an agent can infer the right situation.

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

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

The description only says 'Rename a node' and gives parameter meanings. It does not disclose effects such as whether the rename is persistent, whether references are updated, or whether an error occurs for invalid paths. Since no annotations are provided, this lack of behavioral detail is a significant gap.

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

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

The description is very short and front-loaded with the main action. The parameter bullets are compact and easily parsed. It sacrifices some explanatory depth, but for a simple two-parameter tool, the structure is appropriately concise.

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

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

This is a mutating operation with no annotations, no output schema, and no usage context. The description does not explain path format, whether the operation is reversible, or what happens on failure. Given the breadth of sibling node tools, more context is needed to safely invoke this tool.

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

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

The description adds minimal meaning beyond the schema by saying path is the 'Full path of the operator' and name is the 'New name for the operator.' However, it does not explain expected path formats, name constraints, or uniqueness rules, so it only partially compensates for the schema's lack of descriptions.

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

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

The description states a specific action, 'Rename a node', and identifies the target resource, which distinguishes it clearly from siblings like node_create or node_set_flags. It lacks an explicit contrast with similar tools, but the verb and scope are unambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives, such as whether path or node identifier should be used, or when node_set_flags would be more appropriate. The description simply states the action 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.

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

With no annotations, the description carries the full behavioral burden. It states that flags are set but does not disclose whether passing null leaves a flag unchanged, whether omitted flags are untouched, what side effects occur, or what a successful call returns. This is significant for a mutating tool.

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

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

The main action is front-loaded in the first sentence, and the parameter lines are compact with no filler. Every sentence earns its place.

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

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

This is a relatively simple setter, and the inline parameter docs plus schema make it callable. However, the missing null semantics and lack of any return or error information leave moderate gaps, and there is no alternative-tool guidance.

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?

Despite 0% schema description coverage, the description manually documents all four parameters with meaningful detail, especially 'path: Full path of the operator.' It adds context beyond the schema's raw types/titles, though the meaning of null for display/render/bypass is still not explained.

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

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

The description names a specific verb ('Set') and resource ('display / render / bypass flags on a node'), making it easy to distinguish from sibling node operations like node_create, node_get, or node_rename. It is not a tautology and leaves no ambiguity about the tool's core function.

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 use case is implied by the description: call this when you need to set display, render, or bypass flags on a node. However, it does not explicitly state when not to use it or list alternative tools (e.g., par_set for other node properties), so an agent is left 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 here carries the full burden of behavioral disclosure. It clearly states it captures state, may write to a JSON file, and never overwrites. This communicates a non-destructive side effect and the scope of captured data. Missing details about the return value or failure behavior leave more transparency on the table, but the critical write-safety guarantee is explicit.

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

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

The description is short, front-loaded, and provides the key details in 2 sentences, followed by compact inline parameter docs. It contains descriptive statements instead of tautology, though the phrase 'Diff two snapshots around a risky edit' might deserve rephrasing as it is a suggested workflow rather than a tool operation.

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

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

The tool has only 2 parameters and a relatively simple purpose, so the description covers the essential call details. However, there is no description of the returned data (e.g., whether it returns the snapshot, a file path, or confirmation) and the 'Diff two snapshots' wording is not actionable without clear guidance on how two snapshots would be compared. These are notable gaps for an agent needing to use 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 inline parameter notes are essential. 'Operator path' and 'JSON file under the project folder' add meaning that is absent in the input schema. They are concise and enough for an agent to know what to provide, though they do not explain path format validation or behavior when the file already exists.

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

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

The description identifies a specific action: capture the complete parameter state (value/mode/expr/evalError) plus flags, with an optional JSON file output. It distinguishes itself from sibling node read tools like node_get by emphasizing full state and flags, but the phrase 'Diff two snapshots' introduces ambiguity about whether this tool actually performs a diff or simply supports a diff workflow.

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 a clear suggested context: 'Diff two snapshots around a risky edit.' However, the description does not explicitly state alternatives or provide exclusions, so an agent is not told when not to use this tool or which sibling tool might be more appropriate for other snapshot-like 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?

No annotations are provided, so the description must carry the safety/behavior disclosure. 'Read' signals non-destructive, but there is no mention of return shape, error behavior if path doesn't exist, or globbing semantics beyond one simple example.

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 verb and purpose appear in the first sentence)Skip or precede? The param descriptions are compact and informative dat. Minimal waste; maybe slightly terse but 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 low-complexity 2-param read tool, the description covers inputs but not output/return format or error behavior. With no output schema and no annotations, an agent doesn't know what the tool returns. Acceptable, but incomplete.

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

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

Schema description coverage is 0%, so the description must compensate. It does define path as 'Operator path' and explains the pattern with an example ('t[xyz]') and default behavior ('None = all'), which is more than the schema provides. Still terse; the path semantics are minimal.

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 ('Read') and a clear resource ('parameter values'), and the optional glob filter helps distinguish it from the sibling par_get_all. It is concise and unambiguous about what the tool does.

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

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

The description implies usage with a path and optional glob, but gives no explicit guidance on when to prefer par_get over par_get_all, nor any exclusions. The 'None = all' note hints at behavior but doesn't help an agent choose between 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, the description carries the full burden. It does disclose the kind of output (mode, bounds, menu names) and scope (every par), which is useful. However, it never explicitly states that this is a read-only operation, nor does it mention errors, output shape, or performance implications.

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

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

The description is compact and front-loads the main behavior in the first sentence. The second sentence is necessary to clarify the only parameter, but it redundantly restates the string type already present in the schema, which keeps it from being a perfect 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 one-parameter read-style tool, this is minimally adequate: it names the input and the expected metadata fields. But with no output schema and no annotations, it lacks response structure, path format guidance, and any mention of what 'par' means or how the result relates to sibling tools, leaving the agent to infer important details.

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 one meaningful clarification: path is an 'Operator path,' which is more informative than the schema's bare title 'Path.' Still, it does not specify the expected format or provide an example, so compensation is 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 the tool's result clearly: full metadata (mode, bounds, menu names) for every par under the given path. It does not explicitly use a verb like 'return' or 'get,' and it does not contrast itself with sibling tools such as par_get, so it falls 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 guidance is given about when to use this tool versus alternatives like par_get or par_info. The phrase 'every par' implies broad scope, but there is no explicit when-to-use or when-not-to-use 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 to carry the safety or behavior burden, the description must disclose behavior itself. It does add the important 'names omitted = all' behavior, but it does not explicitly state that the operation is read-only, what the metadata contains, or what happens on an invalid path. 'Metadata' implies a non-mutating call but leaves details unstated.

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

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

The description is extremely compact: a headline behavior, then two parameter definitions. There is no filler, the key optionality is front-loaded, and every sentence earns its place.

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

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

For a two-parameter tool, invocation is mostly clear, but with no output schema and no annotations, an agent does not know the shape of the returned metadata or when to prefer sibling parameter tools. It is enough for a basic call but incomplete for confident tool selection.

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: path is clarified as an operator path, and names are parameter names with None meaning all. This adds real meaning beyond the generic schema titles and default value.

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

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

The description clearly identifies the tool as returning metadata for operator parameters and mentions the 'all parameters' behavior. It is specific about the resource, though it lacks an explicit verb like 'get' or 'retrieve' and does not contrast itself with sibling tools such as par_get or par_get_all.

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 par_info versus par_get, par_get_all, or par_set. The only usage note is that omitting names returns all parameters; an agent must infer relationships from sibling names.

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 and the description does not disclose what 'pulse' actually does—whether it triggers a temporary state change, what side effects occur, or whether it is reversible. The term 'momentary' hints at behavior but is left vague.

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

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

The description is extremely short and front-loaded: the purpose is stated in the first sentenceoley. The parameter descriptions add minimal clutter. This is concise, though arguably too sparse.

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 ricche and no output schema, the description alone must make the tool self-explanatory. It does not define 'pulse,' 'momentary,' or the expected behavior, leaving an agent without enough context to confidently select or invoke it.

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

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

Schema description coverage is 0%, so the description is the only source of parameter meaning. It adds only 'Operator path' and 'Parameter name', which barely extend beyond the schema property names and do not explain formats, constraints, or examples.

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 ('Pulse') and resource ('momentary parameter'), which conveys the core operation and differentiates it from sibling tools like par_get or par_set. However, 'momentary parameter' is somewhat jargon-heavy and not fully explained.

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

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

No guidance is provided on when to use this tool versus alternatives like par_set or par_get. The description gives no exclusions, no context, and no mention of related tools.

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

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

There are no annotations to carry the safety or side-effect profile, so the description bears the full burden. It only states that values are set, with no mention of whether this mutates the operator, whether values are overwritten or merged, whether authorization is needed, or what the tool returns. This is minimal for a setter.

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

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

The description is compact and well-organized: a one-sentence purpose followed by concise parameter definitions. Every sentence contributes useful information and there is no repetition of the schema's type 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?

The description covers both required parameters and the core action, making a basic call possible. However, it omits return behavior, side effects, and any operator/path context, and with no annotations or output schema these omissions leave some ambiguity for an agent deciding whether this tool is appropriate.

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

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

Schema description coverage is 0%, so the description must supply parameter meaning, and it does: 'path' is the operator path and 'values' is a mapping of parameter name to value. This adds real semantic value over the raw schema, though it does not elaborate on value formats or allowed parameter names.

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

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

The description uses a specific verb ('Set') and clearly identifies the resource ('parameter values on an operator'). It is sufficiently clear, though it does not explicitly distinguish itself from the sibling tool par_set_expression, so it does not earn a 5.

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

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

No guidance is given about when to use this tool versus alternatives such as par_set_expression, par_pulse, or node_set_flags. The intended invocation context is implied but never 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 the full burden of behavioral disclosure. It only says the parameter is put into expression mode, without revealing side effects, reversibility, whether existing values are replaced, or what happens to the parameter during the mode change. This is a significant gap for a mutation-like 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 concise and front-loaded, but the following parameter list largely duplicates the input schema and adds little beyond what the schema already displays. It is not bloated, but the extra lines do not meaningfully 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 3-parameter tool with no annotations and no output schema, the description is too sparse to support correct invocation. It does not explain what expression mode is, how the expression interacts with the operator, or what a successful call returns, making it ambiguous in the context of the sibling par_* 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 coverage is 0%, and the description adds only minimal glosses: 'Operator path', 'Parameter name', and 'Python expression string.' 'Parameter name' is tautological, 'Operator path' is vague about whose path, and 'Python expression string' does not explain how the expression is used or formatted. The description fails to compensate for the lack of schema parameter descriptions.

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

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

The description states a specific action: 'Put a parameter into expression mode.' This clearly identifies the verb and resource, and it is distinct from sibling tools like par_set or par_pulse, which deal with values and pulses. However, it does not explicitly explain what 'expression mode' means or contrast itself with those siblings by 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 offers no guidance on when to use this tool versus alternatives such as par_set or par_pulse. It simply states the operation without any context, prerequisites, or exclusions, leaving the agent to infer the appropriate scenario.

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

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

With no annotations available, the description carries the behavioral disclosure burden. It clearly states the main side effects and guardrails: writes a .tox, never a .toe, and never overwrites unless overwrite=true. It does not mention what happens if the target file already exists without overwrite or whether any status is returned, but the core safety-relevant behavior is explicit.

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 behavior and constraints are front-loaded in two terse sentences, followed by a compact parameter list. Every sentence earns its place, and there is no filler or restatement of the tool name.

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

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

For a simple three-parameter export tool with no output schema and no annotations, the description is complete enough: it states the action, the exact file format, the destination scope, the overwrite default, and the meaning of each parameter. The only omissions are minor edge-case behaviors like exact error handling, which are not essential for an agent to select and invoke 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?

The schema has zero parameter descriptions, so the description fully compensates by explaining all three parameters: path identifies the COMP operator, out is the destination .tox under the project folder, and overwrite controls replacing an existing file. This adds real meaning beyond the raw types in the schema.

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

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

The opening phrase 'Save a COMP to a .tox' names a specific action and resource with no ambiguity. The additional constraint 'Never a .toe' makes the output format unambiguous and distinguishes this from any generic export or import tool, especially the inverse sibling project_import_tox.

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

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

The description provides clear practical guidance: only .tox files are produced, and existing files are never overwritten unless overwrite=true. It does not explicitly name the alternative import tool or describe error behavior when the destination exists without overwrite, so it stops short of a fully explicit when-to-use/when-not-to-use statement.

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

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

With no annotations, the description itself must carry the behavioral burden. It does disclose file-type restrictions and path constraints, but it does not describe side effects, success/error outcomes, or what happens if the parent COMP is invalid. Some transparency exists, but important behavioral details remain absent.

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

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

The description is compact and information-dense. The primary action and constraints appear first, followed by clean parameter annotations. No filler or repetition of schema content.

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

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

For a small two-parameter mutation-like tool, the description covers the essential requirements and key edge cases. It lacks some outcome/error information, but it is adequately complete given the simplicity of the tool and the absence of nested objects or output schema.

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

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

Schema description coverage is 0%, so the description must compensate for the empty schema. It explains that path is the .tox file and parentPath is the COMP to load into, with an effective default of '/project1'. This adds meaningful semantics, though it could say more about how parentPath is resolved or validated.

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: 'Load a .tox into a parent COMP.' It names the specific file type and target concept, and the file-type restrictions distinguish it from export/save siblings such as project_export_tox. An agent can understand what the tool does and what it applies to.

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 concrete usage constraints: the path must be under the project folder or $TOUCHBRIDGE_TOX_ROOTS, and .toe files are refused. It does not explicitly name alternatives or say when not to use this tool, but it gives enough context to invoke it correctly.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It implies a read-only info lookup by listing metadata fields, but it does not explicitly state that it has no side effects, whether it operates on the current project, or how errors such as 'no project open' are handled.

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

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

The description is a single tight sentence that front-loads the resource category and the key returned fields. There is no filler or redundant 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 zero-parameter metadata retrieval tool, the field list provides enough information for an agent to know what it will get. The main gap is not explicitly stating the scope (e.g., current project) or output format, but the low complexity keeps this adequate.

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

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

The tool has zero parameters, so there is no parameter semantics for the description to clarify. The baseline of 4 applies because no parameter documentation is needed.

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

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

The description identifies the resource as 'Project + app metadata' and enumerates specific fields ('name, folder, version, cook rate'), so the tool's purpose is clear. It lacks an explicit verb like 'returns' and does not distinguish itself from similar siblings such as system_info or project_versions, but the resource and field list are specific enough.

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

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

There is no guidance on when to use this tool instead of alternatives like system_info, par_info, or project_snapshot. The noun-phrase description implies read-only metadata retrieval, but it gives no context, exclusions, or selection criteria.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'timestamped' and 'collision-free,' which implies it creates uniquely named backups, but it does not disclose side effects, required permissions, whether it overwrites existing files, or what happens on failure. The description is minimal and leaves the agent to infer important behavioral details.

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

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

The description is extremely concise and well-structured. The first sentence states the primary purpose, and the second line provides the only parameter's explanation. There is no redundant filler, and the essential information is front-loaded.

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

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

Given the simplicity of this tool (one optional parameter, no output schema, no annotations), the description covers the core information: what it does and where the backup goes. It does not specify return values or error handling, but for a single-purpose backup tool, these may not be critical. The description is sufficient for an agent to invoke it correctly in most scenarios.

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

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

The description adds meaningful parameter semantics beyond the schema. The schema only lists 'dest' with anyOf string/null and a default null, but the description explains that 'dest' is the backup folder and defaults to 'snapshots/' next to the project. This clarifies the null behavior and default location, which the schema does not convey.

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

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

The description states a specific verb and resource: 'Save a timestamped, collision-free backup .toe.' This clearly indicates the tool creates a backup of a TouchDesigner project file. While it doesn't explicitly differentiate from sibling tools like node_snapshot or bridge_snapshot, the name 'project_snapshot' and the focus on a .toe file make the purpose unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives or any prerequisites. It only states what it does and the parameter default. There is no mention of scenarios where another snapshot tool would be more appropriate, nor any exclusions or context for 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the operation is a listing and mentions ordering, but it does not disclose whether the folder must exist, what happens if no versions are found, whether it scans recursively, or what the return format is. For a tool with no annotations, this is a significant gap.

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

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

The description is two sentences and front-loads the core purpose and ordering. The parameter explanation is compact and useful. It earns its place with no wasted words, though it could be slightly more structured.

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

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

For a simple one-parameter listing tool, the description covers the basic purpose and parameter. However, with no annotations and no output schema, it leaves out return format, error behavior, and edge cases (empty folder, missing folder). It is adequate but not complete.

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

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

Schema description coverage is 0%, so the description must compensate. It does explain the only parameter ('folder') and its default ('default project folder'), which adds meaning beyond the schema's bare type/null/default. However, it does not specify path format, relative vs absolute paths, or behavior when folder is invalid.

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 ('List') and resource ('saved .toe versions in the project folder') and adds ordering ('newest-first'). It is clear and distinguishable from siblings like project_snapshot or bridge_snapshots, though it does not explicitly name a sibling alternative.

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

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

The description implies usage context: it lists saved versions in the project folder, which is a read-only listing operation. It does not explicitly state when to use this tool versus alternatives like bridge_snapshots or project_snapshot, nor does it provide exclusions or prerequisites.

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

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

With no annotations, the description must disclose side effects and behaviors. It only states 'export', implying a file write, but doesn't mention overwriting behavior, directory creation, or that it may cook the TOP. No error conditions or permission issues are noted. This is minimal disclosure 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?

The description is extremely concise: a one-sentence purpose followed by a parameter list. Each parameter gets a line with type and explanation. No filler. The most critical info (format from extension) is front-loaded in the purpose 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 simple 3-parameter tool, the description covers purpose and parameters adequately. However, it lacks any information about return values (though no output schema exists), error handling, or when to use this versus render_screenshot. Without usage guidelines and behavioral caveats, it's only minimally complete.

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

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

The description fully explains all three parameters: path (TOP operator path), save_path (output path with format hint), and quality (JPEG quality with default). This is well beyond the schema which has no property descriptions. The extension-picks-format clarification adds important semantic 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 clearly states the action (export a TOP frame) and the resource (TOP frame) and that format is determined by file extension. It distinguishes from render_screenshot by using 'export' and 'TOP frame', but doesn't explicitly mention that distinction, so it's a clear but not fully differentiated purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives like render_screenshot or node_snapshot. There's no mention of prerequisites (e.g., an active TOP), or whether it's for batch or single exports. This leaves the agent without direction on tool selection.

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

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

With no annotations provided, the description carries the full behavioral burden. It does disclose the file-writing side effect and the tempfile default when save_path is omitted, but it does not mention overwrite behavior, return value, or prerequisites like whether the TOP must be cooked. This is adequate but has clear gaps.

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, scannable, and front-loaded with the main action. The inline type annotations are redundant with the schema, but the overall structure is efficient with 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?

For a simple two-parameter tool, the description is enough to make a basic call. However, because there is no output schema, the missing return-path and overwrite details are notable, and the lack of differentiation from related rendering tools leaves the context incomplete.

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

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

Schema description coverage is 0%, and the description compensates well by explaining both parameters: path is the TOP operator path and save_path is the output PNG path with a tempfile default. This adds meaning beyond the bare schema titles 'Path' and 'Save 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?

The description states a specific action and resource: saving a TOP's current frame to a PNG file. It is clear about the output format, but it does not explicitly distinguish this tool from siblings like render_export or bridge_snapshot, so it lacks direct 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?

There is no guidance on when to use render_screenshot versus alternatives such as render_export or node_snapshot. The description defines the inputs but gives no selection criteria, exclusions, or context for when this tool is the right choice.

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

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

With no annotations provided, the description must fully disclose behavior, but it only says 'Methods/properties/docstring for a td class', lacking details on output format, possible errors, or side effects. For a documentation tool, it is non-destructive, but that is not stated, and the expected result structure is not described.

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 to the point, but the parameter line is redundant, which wastes space. The structure is front-loaded with the purpose, but the inclusion of a bare parameter line adds clutter without substantive 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 single-parameter tool, the description is minimal and leaves out expected output, error behavior, or any additional context. While the tool is simple, an agent could benefit from knowing what format the returned methods/properties/docstring will take, which is entirely absent.

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 merely repeats the parameter name ('name (<class 'str'>): Class or attribute name.'), which adds no meaningful elaboration beyond the schema's own label. With no schema documentation and a description that only states the type, the parameter semantics are essentially undeveloped.

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 that the tool returns 'Methods/properties/docstring for a td class', which identifies the resource as a TouchDesigner class detail. However, it lacks a clear verb and does not differentiate from sibling tools like script_module_help or script_class_list, leaving the purpose somewhat vague.

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

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

The description provides no guidance on when to use this tool versus alternatives. Sibling tools include script_class_list (listing classes) and script_module_help (module help), but the description does not mention them or when to prefer one over another. This gap for a developer-tool context is significant.

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 add useful behavioral detail by stating the filter is case-insensitive and optional, but it does not describe the return format, sorting, or any limitations. For a simple listing tool this is acceptable but not rich.

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 short lines with no filler. The core purpose is front-loaded and the parameter documentation is directly attached. Every sentence earns its place.

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

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

This is a low-complexity listing tool with a single optional parameter, and the description covers both purpose and parameter semantics. The only notable gaps are the lack of explicit return-shape details and lack of alternatives, but for this simple tool the description is largely sufficient.

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

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

The schema only defines pattern as a nullable string, while the description adds meaningful semantics: 'Case-insensitive substring.' This goes beyond the schema by explaining how the parameter is interpreted. It does not cover edge cases like empty-string behavior, but the main semantic is present.

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

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

The description uses a specific verb and resource: 'List names in the td module.' It clearly states the tool lists names and supports an optional substring filter. However, it does not explicitly distinguish itself from the sibling script_class_detail, so the differentiation is only implied by the name and 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?

The description offers no explicit guidance on when to use this tool versus alternatives such as script_class_detail or script_module_help. It describes the pattern parameter but does not state a selection criterion or mention sibling tools, leaving usage context 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 and no return/error/side-effect description, the description carries the full burden of behavior disclosure. It only mentions 'help() output' without specifying format, failure modes, or whether any state changes occur.

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

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

The description is very short and front-loaded, with no wasted wordsasi. However, it is so terse that it misses meaningful context for the single parameter and return behavior.

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 annotations or output schema exist, and the description doesn't explain what a valid name looks like, what the help output contains, or how it differs from related script_* tools. An agent has just enough to guess, but not enough 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 schema already provides a string parameter named 'name'; the description's 'Name to look up' adds no new information. There is no guidance on the expected format, namespace, or valid values for the name.

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

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

The phrase 'help() output for a td name' conveys the general function, but it never defines what a 'td name' is or what form the help output takes. It distinguishes itself from class-oriented siblings only by implying module-level help, without stating it.

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

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

No guidance is given on when to use this tool versus related tools like script_class_list or script_class_detail, nor what valid input names look like. An agent gets no help choosing or preparing an argument.

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

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

No annotations are provided, so the description carries the burden. It does disclose the type of data returned (version, cook rate, realtime flag, method list) and implies a read-only operation. However, it doesn't explicitly state that it's read-only or whether it requires any specific permissions. For a system info tool, this is fairly 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 sentence that is concise and front-loaded with the key elements: version, cook rate, realtime flag, and method list. No extra words, efficient and 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?

Given the tool has no parameters and no output schema, the description is quite complete for what it returns. However, it doesn't mention the format or structure of the 'full registered method list', but that might be minor for a system info tool.

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

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

The tool has zero parameters, and the schema is empty. The description adds essential meaning by listing what information is returned, compensating for the lack of parameters. Since there are no parameters to explain, a high score is appropriate.

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

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

The description clearly states the tool reports system-level information: version, cook rate, realtime flag, and the registered method list. This is specific and distinguishes it from siblings like system_ping (connectivity) and bridge_status (bridge state).

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

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

The description implies this is for retrieving system-wide details, and while it doesn't explicitly mention when not to use it, the context of siblings (e.g., system_ping for pinging) suggests when to choose this tool. No explicit alternatives are named, but the purpose is clear enough for an 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 is the only source of behavioral information. It discloses the expected return ('pong + TD frame'), and the 'canary' metaphor weakly implies a safe, non-mutating operation, but it doesn't explicitly state side-effect-free behavior or failure semantics.

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 short sentences with no filler. The purpose and expected return are front-loaded, making it easy for the agent to parse quickly.

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

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

For a parameterless liveness check, the description is largely complete: it states the tool's purpose and its return value. It could be slightly stronger by explicitly noting the absence of side effects, but given the simplicity of the tool, this 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?

The tool has zero parameters and the schema fully covers that. The description adds no parameter explanation, but none is needed; nothing 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 description uses a clear verb ('Returns') and identifies the tool as a liveness canary that returns 'pong + TD frame'. This conveys the core purpose well, though it doesn't explicitly differentiate it from sibling tools like system_info.

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 'liveness canary' phrasing implies it should be used for health/availability checks, but there is no explicit guidance on when to prefer this tool over alternatives, nor any exclusions. Context is present but minimal.

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 communicates that the tool returns current state, but it does not disclose whether the operation is purely read-only, what errors may occur, what output format to expect, or whether any side effects exist. There is no contradiction with annotations, but the disclosure is minimal.

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

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

At six words, the description is extremely concise with no wasted content, and the core identifier is front-loaded. It is appropriately short for a simple getter, though it is a fragment rather than a complete sentence, so it does not earn a perfect 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 zero-parameter getter with no output schema and no annotations, the description is minimally sufficient to indicate what the tool returns. However, given the large sibling set and lack of structured behavioral data, a clarifying sentence noting that this is a non-mutating read and describing the returned state would make it more complete.

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

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

The tool has zero parameters and the empty input schema is fully covered by the structural data. The baseline for 0-parameter tools is 4, and there is no parameter information the description needs to add.

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

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

The phrase 'Current timeline / playback state' clearly identifies what the tool exposes: a read-only snapshot of the current timeline/playback state. It is distinguishable from siblings like timeline_set, timeline_play, and timeline_pause, but it lacks an explicit verb and reads as a label rather than a complete sentence.

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

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

No guidance is provided on when to use this tool versus related siblings (timeline_set, timeline_play, timeline_pause) or other getters. The intended usage is only implied by the tool name and the word 'current'. An agent is not told about prerequisites, such as whether playback must be running.

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 restates the action without mentioning side effects, preconditions (e.g., must be playing), return values, or error behavior. This is a significant gap for a tool that might have operational nuances.

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 zero wasted words. It is appropriately minimal for a simple action, and the information is front-loaded. 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?

For a zero-parameter action with no output schema and no annotations, the description is nearly sufficient. However, it does not address potential edge cases like whether the tool errors if already paused, whether it toggles, or what the return status is. Given the low complexity, a 3 is appropriate—adequate but with room to add behavioral context.

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