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

No annotations are provided, placing full burden on the description. While it implies a read operation, it does not explicitly state side effects, authentication needs, or rate limits. The description only lists output categories without behavioral guarantees.

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 12-word sentence that captures the core functionality without any fluff. It is appropriately front-loaded and efficiently communicates the action and scope.

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 limited description, the tool lacks completeness. It does not specify the format or structure of the comparison result, leaving the agent to guess how the comparison is presented.

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

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

Schema description coverage is 100%, so baseline is 3. The description reinforces the tool's purpose but adds no extra meaning beyond the schema's own parameter descriptions (e.g., 'First operator 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 description clearly states the tool compares two TouchDesigner operators, specifying it covers parameters, categories, and use cases. This distinguishes it from sibling tools like get_operator (single operator details) and search_operators (search).

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 like get_operator or search_operators. The description does not provide explicit context for selection or mention exclusions.

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

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

No annotations are provided, so the description carries full burden. It explains that the tool returns pre-release build information and lists the types of included details (new features, operators, breaking changes, Python API additions). It does not mention any side effects, which is acceptable for a read operation.

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

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

The description is concise with three sentences, no fluff, and front-loaded with the main purpose. Every sentence adds 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?

Given 5 parameters, no output schema, and no annotations, the description covers the purpose, usage, and return content adequately. It could explicitly state the tool is read-only, but that is implied by the nature of 'returns information'.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds value for the series_id parameter by explaining omission behavior and referencing a sibling tool. The boolean parameters are well-described in the schema, and the description does not add further semantics.

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

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

The description clearly states the tool returns information about a TouchDesigner experimental/beta build series, specifying the resource and action. It distinguishes from sibling tools like list_experimental_builds by focusing on getting details of a specific series.

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

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

The description explicitly says when to omit the series_id to get the latest series and references list_experimental_builds for obtaining available series IDs. This provides clear guidance on parameter usage and directs to the correct sibling tool for listing.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It implies a read-only operation ('browse') and describes the output, but does not explicitly state whether it is side-effect-free, idempotent, or what permissions are needed. This is adequate but not thorough.

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 at two sentences, front-loading the purpose. However, it could be slightly more structured (e.g., listing parameters or expected behavior), but it remains efficient and clear.

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 browsing tool with no output schema, the description adequately explains what is returned (descriptions, code snippets, operator chains, setup notes) and lists all categories. It covers the essential information needed for an agent to use the tool effectively.

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

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

Schema description coverage is 100%, so baseline is 3. The description does not add significant meaning beyond the schema; the schema already lists categories and aliases in the parameter description. The tool description merely repeats a subset, so no extra 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 states the verb 'browse' and the resource 'experimental techniques', with a defined scope of 'by category'. It lists the specific categories and the types of data returned (descriptions, code snippets, operator chains, setup notes). This distinguishes it from sibling tools like get_glsl_pattern or get_experimental_build, which target different resources.

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

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

The description implies usage context by naming categories and return types, but lacks explicit guidance on when to use this tool versus alternatives (e.g., get_experimental_build for builds, get_glsl_pattern for patterns). No when-not-to-use or exclusion criteria are provided.

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

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

No annotations are provided, so the description carries the burden. It states that the code is 'full code ready to paste' and mentions utility libraries, but does not disclose any potential side effects, rate limits, or expected output format. For a read-only retrieval tool, this is adequate but minimal.

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

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

Two sentences plus a usage hint. Every part is informative and there is no redundancy. The main action and key tip are front-loaded.

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

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

For a simple retrieval tool with two parameters and no output schema, the description covers the essential behavior: what is retrieved, how to discover patterns, and what the code is for. No significant gaps remain.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds value by clarifying that 'pattern' can be set to 'list' to see options and by providing example patterns. This extra context goes beyond the schema's static list.

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?

Clearly states the verb 'retrieve', the resource 'GLSL shader patterns or GPU technique code snippets', and the target environment (TouchDesigner GLSL TOP). Distinguishes from sibling tools like get_operator or td_build_glsl by focusing on code snippets.

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

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

Explicitly mentions using 'list' to see available patterns, which guides the agent on how to discover valid inputs. However, it does not contrast with alternatives or state when not to use 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?

No annotations are provided, so the description carries full burden. It fails to disclose whether the tool is read-only, requires network access, or any side effects. It describes what is included but not behavioral traits like data sources or limitations.

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 paragraph with no wasted words. It front-loads the purpose and lists templates concisely. Every sentence adds 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?

Given no output schema, the description should specify return format (e.g., JSON object). It mentions components but not structure. Parameter count is low, but the missing format detail lowers 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 coverage is 100% with clear parameter descriptions. The description adds value by explaining what the template contains (operator list, wire connections, etc.) beyond the schema, helping agents understand the output.

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 that the tool 'Returns a full TouchDesigner network template for a common use case' and lists specific templates, making the verb and resource explicit. It distinguishes itself from sibling tools by focusing on templates for common use 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 does not provide guidance on when to use this tool versus alternatives like td_build_template or suggest_workflow. It lists available templates but lacks explicit context on when this tool is preferred.

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 description bears full burden. It does not disclose behavioral traits like read-only nature, what exactly constitutes 'comprehensive details' (e.g., parameters, outputs), or potential rate limits. Vague phrasing leaves the agent uncertain about side effects.

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

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

Two sentences with no redundant phrasing. Efficiently conveys the core purpose and the optional version parameter without extraneous details.

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

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

Despite no annotations and no output schema, the description fails to clarify what 'comprehensive details' includes, whether the operation is read-only, or how results are structured. This leaves significant gaps for an agent to use the tool effectively.

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

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

Schema coverage is 100%, so parameters are well-documented in schema. Description adds value by noting that version shows compatibility notes, but provides no meaningful addition for name, show_tips, or show_examples beyond their schema descriptions. Baseline score of 3 is appropriate.

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

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

Description states 'Get comprehensive details about a specific TouchDesigner operator' which is a clear verb+resource. It distinguishes from siblings like list_operators (which lists) and get_operator_connections (which focuses on connections) by implying a more general detail retrieval, though not explicitly contrasting.

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?

Mentions optional version parameter for compatibility notes, providing some contextual guidance. However, it lacks explicit instructions on when to use this tool versus siblings (e.g., get_operator_examples for just examples) and no when-not-to-use advice.

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

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

No annotations provided, so the description must cover behavioral traits. It clearly states the tool returns data (read operation) and does not suggest side effects. However, it does not explicitly state it is read-only or safe, which would be ideal with no 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 two concise sentences. The first sentence states the primary purpose and the second provides a concrete example. No unnecessary words, and front-loaded with key 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?

Given no output schema, the description adequately describes the return types (inputs, outputs, chains, port instructions). The parameter count is low and complexity is modest, so the description is largely complete, though it could mention if the output is structured (e.g., JSON) for extra clarity.

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

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

Schema coverage is 100% with meaningful descriptions for both parameters. The description adds extra context by explaining the port instruction format (e.g., 'A output 0 -> B input 0'), which enhances understanding beyond the schema.

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

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

The description clearly states the tool returns upstream inputs, downstream outputs, and common operator chains for a named operator, with connection port instructions. This distinguishes it from siblings like 'get_operator' (basic info) and 'get_operator_examples' (examples).

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 wiring nodes but provides no explicit guidance on when to use this tool versus alternatives (e.g., 'compare_operators') or when not to use it. No exclusion criteria or prerequisites 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?

No annotations are provided, so the description carries full responsibility for disclosing behavioral traits. It does not mention that the tool is read-only, whether authentication is required, or what side effects (if any) occur. The description is minimal and leaves the agent uninformed about safety or state changes.

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 efficiently states the tool's purpose. It contains no fluff, but could be slightly improved by front-loading the most critical information (the verb and resource) earlier, though it already does so. It 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?

Given the tool's modest complexity (2 parameters, no output schema), the description is adequate but not comprehensive. It does not explain what the returned examples look like (e.g., whether they include syntax highlighted code or code blocks). The absence of annotations and output schema leaves some uncertainty for the agent.

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

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

With 100% schema coverage, the baseline is 3. The description adds value by contextualizing the 'example_type' parameter as covering 'Python code examples, expressions, and usage patterns' and by providing illustrative operator name values (e.g., 'Noise CHOP'). This enhances the schema's minimal 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 clearly states the action ('Get'), the resource ('Python code examples, expressions, and usage patterns'), and the context ('for a specific TouchDesigner operator'). It distinguishes this tool from siblings like get_operator (which retrieves operator properties) and get_python_api (which provides API references) by focusing on usage examples.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention when not to use it, prerequisites, or related tools such as get_operator or search_operators. The agent must infer usage from the tool name alone.

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

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

No annotations are provided, so the description carries the full burden. It states the tool gets documentation and can filter by version, but does not mention whether it is read-only, has rate limits, or what exactly is returned (text, structure, etc.). The behavior is partially clear but missing important 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?

Two sentences front-load the purpose and key optional filter. No superfluous words or repetition. Efficient and focused.

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 5 parameters (1 required) and no output schema, the description covers the main purpose and version filter but omits details on boolean flag interactions and the format of returned documentation. More context would help an agent use it effectively.

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

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

The input schema has 100% coverage with descriptions for all 5 parameters. The description adds minimal value beyond the schema: it mentions optional version filtering but doesn't explain the interplay between show_members, show_methods, and show_inherited. With full schema coverage, a baseline of 3 is appropriate.

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

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

The description clearly states the tool retrieves documentation for a TouchDesigner Python class with optional version filtering. It specifies the resource ('TouchDesigner Python class') and action ('Get documentation'), distinguishing it from sibling tools like search_python_api and list_python_classes.

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 when needing documentation for a specific class, but does not explicitly state when to use this tool over others, nor does it provide conditions or prerequisites. Usage is inferred but not guided.

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 lacks behavioral context such as whether the operation is read-only, requires authentication, has rate limits, or what happens with missing tutorial names.

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

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

The description is a single sentence, which is concise but too brief. It could include more useful information without becoming verbose.

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

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

The description does not clarify the meaning of 'detailed content', return format, or behavior when optional boolean flags are omitted. Incomplete for a tool with 4 parameters and no 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 coverage is 100% with clear descriptions for each parameter. The tool description adds no extra semantic value beyond the schema.

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

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

The tool name and title clearly indicate it retrieves a TouchDesigner tutorial. The description specifies 'detailed content', distinguishing it from sibling tools like 'list_tutorials' and 'search_tutorials'.

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. No mention of prerequisites, when not to use it, or links to 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?

No annotations exist, so description must disclose behavior. It implies a safe read operation but does not explicitly state it is non-destructive or that it does not modify state. Adequate but not fully 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?

Single sentence of 18 words, immediately states purpose and key outputs. 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?

No output schema; description hints at return fields (Python version, operators, features, API changes). Sufficient for basic understanding but could mention response structure or example.

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

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

Schema covers all 4 parameters with descriptions (100% coverage). The description adds no extra parameter context beyond the schema. Baseline 3 is appropriate.

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

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

Description clearly states the tool retrieves detailed version info including specific categories (Python version, new operators, features, API changes). It distinguishes from sibling get_experimental_build via parameter description.

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 'version' parameter description explicitly tells when to use get_experimental_build instead. No other when-to-use or when-not-to-use guidance is provided, but the key alternative is covered.

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

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

No annotations are provided, so the description carries the behavioral burden. It describes the output structure but does not disclose whether the operation is read-only, authentication requirements, or any limitations like pagination or result size. For a list operation, the risk is low, but transparency could be improved.

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 (three sentences), front-loaded with the core purpose, and structured to list feature areas and entry contents. Every sentence adds value, with no extraneous details.

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

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

Given 5 parameters, no output schema, and no annotations, the description adequately explains the tool's purpose, output contents, and provides a cross-reference to a related tool. It lacks details on pagination or exact response format, but is fairly complete for a list tool.

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

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

Schema description coverage is 100%, so the schema already documents all 5 parameters well. The description adds minimal extra meaning, such as listing the default behavior for omitting feature_area. Baseline score of 3 is appropriate as the description does not significantly enhance parameter understanding beyond the schema.

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

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

The description clearly specifies the tool lists experimental/beta build series grouped by feature area, with explicit feature areas and entry contents. It distinguishes from the sibling tool get_experimental_build which retrieves details for a specific series.

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

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

The description states when to use this tool (to list recent experimental builds grouped by feature area) and directs users to get_experimental_build for full details on a specific series. However, it does not explicitly exclude cases or compare to other list tools.

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

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

No annotations are present, so the description must disclose behavioral traits. It only states that the tool lists operators with 'contextual grouping', but does not reveal aspects like pagination, scope, or whether all operators are always returned. This is insufficient for a listing tool.

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

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

The description is a single sentence, which is concise. However, the phrase 'contextual grouping' is ambiguous, reducing clarity. It earns its place but could be more precise.

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 only one optional parameter and no output schema, the description should clarify the output format and the meaning of 'contextual grouping'. It omits these details, making it incomplete for an agent to understand what the tool returns.

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

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

Schema coverage is 100%, so the schema fully documents the single optional parameter. The description adds no additional meaning beyond what the schema provides; 'contextual grouping' does not relate to the parameter.

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

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

The description uses a specific verb 'list' and identifies the resource 'TouchDesigner operators'. It distinguishes from sibling tools like 'search_operators' or 'get_operator'. However, 'contextual grouping' is vague and could be clarified.

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 'search_operators' or 'compare_operators'. There is no explicit context for usage or exclusion.

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

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

No annotations provided, so description carries full burden. It does not disclose behavioral traits such as whether the operation is read-only, performance characteristics, or any side effects. Minimal transparency.

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

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

Single sentence that is front-loaded and clear. Every word is necessary; no redundancy or wasted 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?

For a simple listing tool with optional parameters and no output schema, the description is minimally complete. However, it lacks guidance on return format or when to use this versus searching, which would improve completeness.

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

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

Schema coverage is 100% with descriptions for all three parameters. Description adds only general context of filtering. Baseline score of 3 applies as schema already explains parameters.

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

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

Description specifies verb 'List' and resource 'TouchDesigner Python API classes' with optional filtering. Clearly distinguishes from sibling tools like 'search_python_api' which performs 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?

Description implies usage for listing classes but does not explicitly guide when to use this tool over alternatives like 'search_python_api' or 'get_python_api'. No when-not-to-use or exclusion criteria 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 exist; the description does not disclose any behavioral aspects such as idempotency, side effects, permissions, or rate limits. It fails to add behavioral transparency beyond the basic 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 a single concise sentence that is front-loaded and contains no superfluous 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?

With three optional parameters, no output schema, and no annotations, the description is minimal. It does not explain default behavior, sort order, or typical use cases, which leaves gaps for a complete understanding.

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

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

Schema description coverage is 100%, so all parameters are already documented. The description does not add any extra meaning beyond the schema, resulting in a baseline score of 3.

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

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

The name and title clearly indicate listing tutorials. The description specifies the verb 'list' and resource 'tutorials' with 'summaries', distinguishing it from siblings like 'get_tutorial' and 'search_tutorials'.

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 'search_tutorials' or 'get_tutorial'. No prerequisites or context for selection are given.

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

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

With no annotations, the description carries the burden. It describes the output fields but does not explicitly state it is a read-only operation or disclose any limitations like pagination or rate limits. Adequate but leaves 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?

A single sentence that efficiently communicates purpose and content. No wasted words, front-loaded with the action and resource.

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

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

For a simple list tool with three optional parameters and no output schema, the description is sufficient. It covers the main output fields and scope. Could mention return format (e.g., array) but not necessary.

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

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

Schema coverage is 100% with each parameter already having a clear description. The tool description adds no additional insight beyond what the schema provides, so baseline 3 is appropriate.

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

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

The description clearly states the tool lists all supported TouchDesigner versions with specific fields (Python versions, support status, feature highlights). However, it does not explicitly distinguish itself from sibling 'get_version_info' which likely targets a single version.

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

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

No guidance on when to use this tool versus alternatives like 'get_version_info'. No context on prerequisites or filtering behavior beyond parameter descriptions.

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

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

Without annotations, the description carries the full transparency burden. It adds context by specifying searchable fields (keyword, operator name, tag, code pattern) and categories, but does not disclose safety traits like read-only behavior, rate limits, or pagination. It is neither contradictory nor detailed, warranting a middle score.

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 that front-loads the main action. It efficiently conveys scope and searchable attributes without unnecessary words, though a slight restructuring could improve readability.

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 tool's domain and search capabilities but omits expected output format, result ordering, or pagination details. Given no output schema and moderate parameter count, the description is adequate but not fully comprehensive.

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

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

Schema coverage is 100% with detailed parameter descriptions. The description reinforces param purposes (e.g., categories map to category_filter) but adds limited new meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool searches across TouchDesigner experimental technique categories, listing specific domains like GLSL, GPU compute, machine learning, etc. It distinguishes from sibling search tools like search_operators by explicitly targeting experimental categories.

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 explicit guidance on when to use this tool versus alternatives. It does not mention exclusions or comparisons to sibling tools such as search_operators or get_experimental_techniques, leaving the agent to infer usage from the description alone.

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

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

With no annotations provided, the description carries the full burden. It discloses key behaviors: supports multi-term queries, typo tolerance, version filtering, and multiple search types. It does not mention rate limits or side effects, but as a search tool, it is expected to be read-only. The description adequately conveys its operational characteristics beyond the minimum.

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 well-structured sentence that front-loads the main purpose and lists supporting features efficiently. While it packs many features, it remains clear and easy to parse. Minor improvement could be splitting into two sentences for readability, but it is appropriately sized for the complexity.

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

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

Given the tool has 8 parameters, high schema coverage, and no output schema, the description provides a good overview of capabilities. It mentions advanced contextual analysis and ranking, hinting at output ordering, and covers major filtering options. It does not detail pagination (limit parameter) or result format, but these are captured in the input schema. Overall, it is sufficiently complete for an agent to understand its scope.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description provides a high-level summary of supported features (e.g., 'category/subcategory filtering, parameter search') but does not add new meaning beyond what the parameter descriptions in the schema already state. It reinforces but does not extend the schema explanations.

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 'Search for operators' using a specific verb and resource. It lists advanced features (multi-term, filtering, typo tolerance) that distinguish it from sibling tools like list_operators, which likely provides a simple list, or get_operator, which retrieves a single operator. The purpose is unambiguous and well-differentiated.

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

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

The description implies when to use this tool (for advanced search with filtering and ranking) but does not explicitly state when not to use it, nor does it mention alternative tools like list_operators for simpler needs. The listing of features gives context, but lacks explicit guidance on tool selection among siblings.

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

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

No annotations provided, so description carries full burden. It adds context about version filtering meaning but does not disclose any potential limitations or side effects beyond what schema parameters already indicate.

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?

Extremely concise with two sentences, no fluff. However, could benefit from additional structure like listing key parameters or usage examples to enhance readability.

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 5 parameters and no output schema, the description is minimal. It lacks information about return format or behavior when no results, making it moderately complete.

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

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

Schema coverage is 100%, so baseline is 3. The description restates the version filter meaning already present in the schema, adding no new semantic value for parameters.

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

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

The description uses specific verb 'search' and specifies resources: 'Python classes, methods, and members'. It also mentions optional version filtering, which distinguishes it from sibling tools like list_python_classes or get_python_api.

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 searching Python API but does not explicitly state when to use this tool over alternatives like search_operators or get_python_api. No when-not-to-use advice is provided.

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

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

No annotations are provided, so the description must fully disclose behavior. While the tool is a search and likely read-only, the description does not explicitly state safety, idempotency, or side effects. Adding 'Returns matching tutorials without modifying data' would improve transparency.

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

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

The description is a single concise sentence with no redundant information. However, it could be slightly more informative without losing conciseness, such as including the default behavior of 'search_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 has no output schema, and the description does not explain return format, pagination, or ordering. For a search tool with multiple parameters, this missing information 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?

The input schema has 100% coverage with descriptions for all three parameters. The tool description mentions 'keyword, topic, or content', which loosely maps to the 'query' and 'search_content' parameters, but it does not add new semantic information beyond the schema.

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

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

The description clearly states the verb 'Search' and the resource 'TouchDesigner tutorials', and mentions filters by 'keyword, topic, or content'. However, it does not distinguish this tool from sibling search tools like 'search_operators' or 'search_python_api', which could cause confusion.

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 'list_tutorials' or other search tools. The description only states what it does, leaving the agent to infer usage 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?

With no annotations, the description fully bears the transparency burden. It discloses that the tool returns connection instructions, complexity, node count, and minimum version. However, it does not explain the basis of suggestions (e.g., common usage patterns) or potential side effects like network state dependency.

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 efficiently conveys purpose and output. It is well-structured but could be slightly improved by listing the output fields more clearly, though it remains concise and front-loaded.

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

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

For a tool with one parameter, no output schema, and no annotations, the description fully covers what the tool does and what it returns. It is complete and sufficient for the agent to understand and 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?

The schema covers the single parameter 'current_operator' with a description. The tool description adds value by providing examples ('Movie File In TOP', 'Constant CHOP'), giving agents a better sense of valid inputs beyond the schema.

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

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

The description clearly states the tool's purpose: providing workflow suggestions for operators following a current one, and lists specific return fields (connection port instructions, complexity rating, node count, version). This distinguishes it from sibling tools like get_operator_connections or compare_operators.

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 when the user has an operator and wants to know common next steps, but it does not explicitly state when to use this tool versus alternatives, nor does it mention when not to use it.

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

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

Since no annotations are provided, the description carries the full burden. It discloses key behavioral traits: for unsupported techniques, it does not fabricate connections and returns code with explanation; for supported techniques, it creates specific operators and lays them out. It also mentions the default parent COMP. However, it does not discuss permissions, overwriting behavior, or potential side effects.

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

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

The description is a single well-structured paragraph that uses capitalization for emphasis (COMPILE, SUPPORTED, UNSUPPORTED) and logically separates the two cases. Every sentence contributes valuable information without redundancy. It is appropriately concise for the complexity of the task.

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 output schema, the description should at least hint at return values. It describes the side effects (creating operators) but does not specify what the function returns (e.g., success message, operator references). It also omits error handling or prerequisites beyond the bridge. For a complex build tool, this is a 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?

Schema coverage is 100%, so baseline is 3. The description adds some meaning beyond the schema: it provides examples for 'technique' (raymarching_basic, Gray-Scott Reaction-Diffusion) and clarifies the 'parent' default (/td_mcp/sandbox). However, this added value is modest relative to the 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 uses a specific verb 'COMPILE' and clearly identifies the resource as 'GLSL shader technique' from the experimental GLSL knowledge base. It distinguishes between supported and unsupported techniques, and mentions the 'list' option for enumeration, which differentiates it from sibling tools like td_build_pattern or td_build_template.

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 explicit guidance on when to use this tool: it handles supported techniques by creating operators, and unsupported techniques by returning code without connections. It mentions building into the sandbox by default and the requirement for the bridge (td_status). However, it does not explicitly state when not to use this tool or compare it to alternatives like td_build_pattern.

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?

Discloses key behaviors: creates operators in workflow order, wires as straight chain, lays out network, limitation on multi-input, hard-errors if operator name missing createType, requires bridge. No annotations provided, so description carries full burden and does so thoroughly.

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

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

Single paragraph but well-structured with key points in caps for emphasis. Each sentence adds meaningful information without redundancy. Slightly verbose but justified by the complexity.

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

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

Given the complexity and absence of output schema, the description covers workflow, limitation, default parent, and error handling. Could mention behavior on existing operators in sandbox, but overall complete enough for agent to use correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining what 'pattern' means (name in data/patterns.json with examples) and the default for 'parent', going beyond 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 clearly states the verb 'COMPILE' and the resource 'linear workflow pattern from data/patterns.json', specifying that it builds into a running TouchDesigner instance. It explicitly differentiates from sibling tool td_build_template for branched networks.

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

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

Explicitly states when to use (linear single-input chains) and when not to (multi-input nodes), with a direct alternative: 'use td_build_template for branched networks'. Also mentions default parent and error behavior, providing clear usage context.

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

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

No annotations are provided, so the description carries the full burden. It discloses the default sandbox path, strict failure on unresolved items, and alias handling. However, it does not mention whether existing operators in the target parent are overwritten or preserved, nor does it describe the return value or side effects on the sandbox. This 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 description is concise and well-structured. It starts with the core action, then lists template options, default behavior, and failure mode. Every sentence adds essential information without redundancy.

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

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

Given the lack of annotations and output schema, the description covers key aspects: action, templates, default path, strict failure mode, and prerequisite. It omits the success return value and details about idempotency, but overall it provides sufficient context for an agent 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 coverage is 100%, so baseline is 3. The description adds value beyond the schema by explaining the default parent path, listing template names and aliases, and noting that 'list' can be used to see available templates. This enriches the parameter meaning for the agent.

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 ('COMPILE') and clearly identifies the resource (TouchDesigner network template). It lists the actions (creates operators, sets parameters, wires connections, lays out network) and enumerates template names, distinguishing this from sibling tools like td_build_glsl or td_create_operator.

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

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

The description explains the strict failure behavior and the prerequisite (bridge running, referencing td_status). It does not explicitly state when to use this tool versus building operators individually or using other network tools, but the context of building a full template is implied. Slightly better guidance on alternatives would raise the score.

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

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

With no annotations, the description carries the full burden. It discloses the destructive action (delete), the confined scope (only sandbox), and the operational dependency (bridge running). It does not cover reversibility or error states, but for a simple clearing tool, this is adequate.

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

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

Two sentences with no waste. The first sentence delivers the core action, and the second adds constraints and prerequisites. Front-loaded and 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?

Given the tool's simplicity (one optional parameter, no output schema), the description covers all necessary context: what it does, where it operates, what it excludes, and a prerequisite. Complete for its complexity level.

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

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

The schema coverage is 100%, so the baseline is 3. The description does not add significant extra meaning beyond the schema's parameter description, but it confirms the default path and intent. No additional value added.

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

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

The description clearly states the verb 'delete', the resource 'every operator inside the live-control sandbox COMP', and the scope 'only clears operators within the sandbox'. It effectively distinguishes from sibling tools like td_delete by specifying the batch-clearing nature.

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

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

The description explicitly states when to use (clearing the sandbox) and what it will not affect (rest of project). It mentions a prerequisite (bridge running) and references td_status for checking. While it does not name an alternative sibling directly, the context implies td_delete for individual removals.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It reveals that the tool wraps a documented API call and includes the exact syntax, which aids transparency. However, it does not mention potential side effects (e.g., modifying the network graph), error handling, or permissions needed.

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

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

The description is two sentences with no unnecessary words. The first sentence states the core purpose, and the second provides technical detail. It is front-loaded and 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?

Given the tool's simplicity (4 parameters, no output schema), the description is fairly complete. It explains what it does, how it works via the API call, and gives an example. However, it lacks mention of common failure cases or prerequisites like both operators must exist.

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

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

The input schema already provides 100% coverage with descriptions for all parameters. The description adds context by explaining the overall operation and giving an example of full paths, but it does not significantly deepen understanding beyond the schema's own 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 clearly states the tool connects one operator's output to another's input in a live TouchDesigner instance, with a specific verb ('Connect') and resource ('operator's output to another operator's input'). It also references the underlying API call, distinguishing it from sibling tools like td_create_operator or td_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?

The description implies usage for connecting operators but does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions or prerequisites. The context of sibling tools makes it somewhat clear, but explicit guidance is missing.

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 traits. It mentions live control and wrapping a documented call, but does not cover error states, permissions, or side effects like overwriting existing operators.

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

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

Three concise sentences that front-load the purpose, then explain the wrapper and key parameter details. 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?

The description covers main behavior and default values, but lacks information about return value, error handling, or prerequisites like parent COMP existence. Given no output schema, more complete context would help.

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

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

Schema coverage is 100%, but the description adds value by explaining op_type resolution from token to display name and mentioning the default parent and default name behavior, which goes beyond the schema.

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

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

The description clearly states the tool creates an operator inside a parent COMP in a live TouchDesigner instance, using a specific verb and resource. It distinguishes from sibling tools like td_delete or td_connect by focusing on creation.

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 context like default parent path and op_type resolution, but lacks explicit when-to-use or when-not-to-use guidance relative to alternatives. Usage is implied but not fully clarified.

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 fully discloses that the action is permanent and removes the operator and its children ('This permanently removes the operator and any of its children.'). It also mentions live control context.

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

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

The description is extremely concise: two sentences that front-load the action and context without any 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 simple destructive tool with one parameter, the description covers purpose, behavior (permanent + recursive), and safe usage. Missing details about return value or error handling, but overall 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?

Schema coverage is 100%, but the description adds value by explaining the path parameter with an example ('e.g. '/td_mcp/sandbox/noise1'') and recommending staying within the sandbox, which is beyond the schema's description.

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

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

The description clearly states the action (delete/destroy), the resource (operator in a running TouchDesigner instance), and the context (live control via td_mcp bridge, wrapping op.destroy()). It distinguishes from siblings by focusing on destruction.

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 guidance on safe usage: 'Target a path inside '/td_mcp/sandbox' to stay within the safe work area.' However, it does not explicitly state when not to use the tool or mention alternatives among siblings.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It correctly indicates a read operation but does not elaborate on side effects, permissions, or constraints. The description is adequate but minimal.

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

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

Two concise sentences that front-load the action and resource, followed by a practical use case. Every sentence earns its place with no 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?

Given the tool's simplicity (2 parameters, no output schema), the description adequately covers what it does, when to use it, and references the documented output format. Minor lack of detail on return structure is acceptable for a list-like 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 coverage is 100% with both parameters described in the schema. The description adds no extra meaning beyond what the schema already provides, so baseline score 3 is appropriate.

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

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

The description clearly states the verb 'read' and the resource 'cook errors, warnings, and script errors from an operator'. It specifies the context ('live control via the td_mcp bridge') and distinguishes from sibling tools, none of which duplicate this functionality.

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

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

The description provides a clear use case: 'Use this to diagnose why a node is not cooking after a build/edit.' It does not explicitly state when not to use or list alternatives, but the context is sufficient and no sibling tool serves the same purpose.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It states the tool auto-arranges operators but does not clarify whether it is destructive (permanently changes node positions), reversible, or how it handles existing layouts. It also does not mention any side effects or constraints, leaving significant 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?

Two concise sentences: the first directly states the purpose, the second covers default operation and prerequisite. Every word is necessary, and the structure is front-loaded with the core action. No redundancy or 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 one-parameter layout tool, the description covers the basic function, default target, and a key requirement. However, it does not explain what 'auto-arrange' entails algorithmically or mention that it modifies nodes (destructive nature). Given no annotations and no output schema, it leaves gaps that could confuse an agent about side effects or reversibility.

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

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

Schema coverage is 100% for the single parameter 'parent', which already includes a description of its default value. The description repeats this default (/td_mcp/sandbox) and adds a requirement about the bridge, but adds no new semantics beyond what the schema provides. Thus, baseline score of 3 is appropriate.

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

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

Description explicitly states the tool auto-arranges operators in a TouchDesigner network for tidiness and readability. The resource (operators inside a network) and verb (auto-arrange) are specific, and the tool is clearly differentiated from sibling tools that focus on getting information, building, or other actions.

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

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

The description gives clear context: it operates on the sandbox COMP by default and requires the TouchDesigner bridge. It references td_status for checking the bridge. However, it does not provide explicit when-to-use or when-not-to-use guidance relative to other tools, though the purpose is self-evident.

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

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

No annotations are provided, so the description alone must convey behavior. It correctly indicates that the tool reads network contents with no destructive side effects. However, it does not disclose error behavior (e.g., if the parent path is invalid or the bridge is unavailable), which would strengthen transparency.

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

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

Two concise sentences convey purpose, return values, default, and prerequisite. Every sentence adds value with no redundant information. The structure is front-loaded with the core action and result.

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

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

Despite lacking an output schema, the description explicitly states what is returned. It covers the default parent, prerequisite, and essential context for a list operation. No additional information is necessary for correct invocation.

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

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

Schema coverage is 100%, meaning the input schema fully documents both parameters. The description only adds the default value for 'parent' ('/td_mcp/sandbox') which is already in the schema's description. Since the schema carries the burden, a score of 3 is appropriate.

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

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

The description uses a specific verb ('List') and identifies the resource ('operators inside a TouchDesigner network'). It distinguishes from sibling tools like 'list_operators' by focusing on a parent COMP's children. The return fields are clearly enumerated, making the tool's purpose unambiguous.

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

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

The description states the default parent and a prerequisite ('requires the TouchDesigner bridge to be running, see td_status'). It implies when to use this tool (e.g., to inspect a specific network's contents) without explicitly excluding alternatives. The guidance is clear but lacks explicit 'when not to use' or named sibling differentiators.

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 live control aspect and the underlying call (TOP.saveByteArray()). It does not contradict any annotations, but could detail side effects 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 extremely concise, using two sentences to convey purpose, use case, and implementation detail without superfluous content. The structure appropriately front-loads the primary action.

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

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

Given no output schema, the description states it returns an image for the assistant to see. It lacks specifics on return format (e.g., base64 versus file path), but is sufficient for an agent to understand the tool's role in the workflow.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds marginal value by mentioning 'current frame' and the underlying call, but does not provide additional semantic detail beyond the schema's 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 explicitly states the action ('Render the current frame of a TOP') and the resource ('TOP'), with the outcome ('return the image so the assistant can see the result'). This clearly differentiates it from sibling tools like td_run_python or td_sample.

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 advises using the tool 'after building/editing a network to visually verify the output.' This provides clear context for when to use it, though it does not explicitly state when not to use it or mention alternative tools.

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

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

No annotations exist, so description carries full burden. Warns about arbitrary code execution with full project and host environment access, explains disable-by-default behavior, and describes return content (stdout, value, errors). This fully discloses essential behavioral traits.

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?

Compact and well-structured: purpose, warning, usage guidance, return content all in a few sentences. No wasted words—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?

Given no output schema, the description covers return values and error types. Explains execution environment and failure conditions. Complete for a simple one-parameter tool with no nested outputs.

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?

Single parameter 'code' has schema description with Python context details. The description adds environment context (td module available) and repeats the Allow Python flag condition, adding value beyond the schema. With 100% schema coverage, baseline is 3; the extra context justifies a 4.

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

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

Clearly states the tool runs arbitrary Python code in a TouchDesigner instance. The verb 'run', resource 'Python code', and scope 'arbitrary' and 'inside a running TouchDesigner instance' are explicit. Distinguishes from sibling live-control tools by naming them as preferred alternatives.

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

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

Explicitly advises when to use (ad-hoc Python not expressible by other tools) and when not to use (prefer structured tools for normal operations). Also notes the tool is disabled by default and requires explicit 'Allow Python' flag, providing critical context for invocation.

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

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

No annotations are provided, so the description carries the full burden. It explains that the tool operates via the td_mcp bridge and samples values, but does not disclose potential errors, side effects, or whether it is strictly read-only (though sampling implies read-only). Additional behavioral context (e.g., what happens if the operator path is invalid) would improve transparency.

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

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

The description is two sentences long, front-loaded with the primary purpose, and every sentence adds value. It is concise and well-structured, 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?

Given 5 parameters and no output schema, the description covers the main functionality and each parameter's role. It mentions the return type is a 'single value' but does not specify whether it is a number, string, or other. This minor gap is offset by the clarity of the sampling methods.

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

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

Schema description coverage is 100%, so each parameter already has a description. The tool's description adds value by linking the kind parameter to the underlying TouchDesigner methods (CHOP.chan and TOP.sample) and clarifying the context for u, v, and channel. This goes beyond the schema's standalone 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 clearly states that the tool samples a single value from a TouchDesigner operator, with two specific sampling kinds (chop_channel and top_pixel). This distinguishes it from siblings like get_operator or compare_operators, which do not offer live sampling.

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

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

The description explicitly says to use the tool 'to verify concrete output values without rendering a full frame' and explains the two kinds with examples. It does not explicitly state when not to use it, but the use case is clear and alternatives are not needed given the tool's specificity.

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

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

No annotations are provided, so the description carries the full burden. It explains the behavioral traits (drives specific members, live control) but does not disclose potential side effects, required permissions, or reversibility. Adequate but not comprehensive.

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 (two main sentences plus a continuation) and front-loaded with the core purpose. Every sentence adds value, though it could be slightly more streamlined without losing 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?

Given the tool's complexity (5 parameters, mutual exclusivity, label resolution) and no output schema, the description provides sufficient context to use the tool effectively. It covers parameter usage, required fields, and the effect on the operator.

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

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

Schema coverage is 100% with all parameters described. The description adds significant meaning beyond the schema: it clarifies the mutual exclusivity of value/expr/pulse, explains that parameter can be a label or exact name, and describes the underlying member access. This provides useful context for proper invocation.

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 sets a parameter on an operator in a running TouchDesigner instance for live control. It specifies the internal members affected (val, expr, pulse) and distinguishes from sibling tools by focusing on parameter mutation rather than retrieval or other operations.

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 explicit guidance on mutual exclusivity of value/expr/pulse and describes how parameter labels are resolved. While it does not mention when to use this tool over alternatives, the context of the tool (live parameter setting) is clear from the title 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 provided, so description bears full burden. It notes 'live control' but does not disclose side effects (e.g., immediate re-render, parameter persistence), error handling, or requirements (e.g., TOP must exist). This is minimal for a mutation tool.

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

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

Two sentences, no fluff. Front-loaded with verb and resource. Every word adds 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?

Given no output schema, the description should clarify return behavior. It does not. Also lacks detail about valid TOP types or error cases. Adequate for simple mutation but could be 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?

Schema coverage is 100%, with clear parameter descriptions (path with example, dimensions with constraints). The description adds little beyond restating 'resolution parameters'—no additional usage context for the parameters.

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

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

The description clearly states the action ('Set'), the resource ('output resolution of a TOP'), and context ('live control via td_mcp bridge'). It distinguishes itself from sibling tools like td_set_parameter by focusing specifically on resolution settings.

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

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

The description implies the tool is for live resolution changes but lacks explicit guidance on when to use it versus alternatives (e.g., td_set_parameter). No prerequisites or when-not-to-use are mentioned, 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?

With no annotations, the description explains it reads env vars and returns a status or hint. Does not cover missing env vars but is adequate for a simple read-only check.

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

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

Three sentences, each informative: purpose, output, configuration. No wasted words, front-loaded.

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

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

For a zero-parameter tool with no output schema, the description covers what it does, what it returns, and how it is configured. Fully 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?

No parameters in schema; description usefully explains configuration via environment variables, adding meaning beyond the empty schema.

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

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

Clearly states the tool checks bridge reachability and token acceptance. Distinct from sibling td_connect which establishes a connection, and other 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?

Describes the tool's purpose (check status) but does not explicitly state when to use alternatives. However, context with siblings makes it clear it is for status verification.

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