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 mentions the tool sets up delayed live streaming but doesn't describe whether this is a mutation (likely yes), what permissions are required, whether it affects ongoing streams, rate limits, or error conditions. The return value '请求ID' (request ID) is noted but without context on how to use it. Significant behavioral gaps remain.

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 with clear sections for Args and Returns. It uses minimal words to convey the core function. However, the front-loaded purpose statement is very brief ('设置延时直播') and could be more informative without sacrificing conciseness.

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

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

Given no annotations and no output schema, the description is incomplete for a mutation tool with 5 parameters. It lacks behavioral context (e.g., side effects, permissions), doesn't differentiate from siblings, and provides minimal guidance. The return value is mentioned but without detail on format or usage. More context is needed for safe and effective use.

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 parameters thoroughly with examples and constraints. The description lists parameters but adds no meaning beyond what the schema provides (e.g., it doesn't explain relationships between parameters or usage nuances). Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description states the tool '设置延时直播' (sets up delayed live streaming), which is a clear verb+resource combination. However, it doesn't distinguish this from sibling tools like 'resume_delay_live_stream' or explain what differentiates 'add' from 'resume' in this context. The purpose is understandable but lacks sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'resume_delay_live_stream' or 'forbid_live_stream'. It doesn't mention prerequisites, use cases, or exclusions. The agent must infer usage from the tool name alone, which is insufficient.

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

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

No annotations are provided, so the description carries full burden. It states '添加域名' (add domain) which implies a write/mutation operation, but doesn't disclose behavioral traits like required permissions, whether this is idempotent, rate limits, or what '请求ID' (request ID) in the return means. The description is minimal and lacks crucial operational context for a domain creation 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 extremely concise with just '添加域名' (add domain) followed by parameter and return documentation. While efficient, it's arguably under-specified rather than optimally concise. The structure with Args/Returns sections is clear but minimal.

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 domain creation tool with 6 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain what happens after adding a domain, error conditions, or relationship to other live streaming operations. The return value '请求ID' (request ID) is mentioned but not explained. More context is needed for effective use.

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 parameters thoroughly with descriptions, examples, and defaults. The description lists parameter names in Chinese but adds no additional meaning beyond what's in the schema. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description states '添加域名' (add domain) which provides a basic verb+resource, but it's vague about what type of domain (live streaming domain) and doesn't distinguish from sibling tools like 'add_delay_live_stream' or 'enable_live_domain'. The purpose is clear at a high level but lacks specificity for this context.

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

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

No guidance on when to use this tool versus alternatives like 'enable_live_domain' or 'add_delay_live_stream'. The description provides no context about prerequisites, when this is appropriate, or what happens after adding a domain. Usage is implied through parameter names but not explicitly stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. While '创建' (create) implies a write operation, the description doesn't specify required permissions, whether the task starts immediately, error handling, rate limits, or what happens if parameters are invalid. For a complex 26-parameter mutation tool with zero annotation coverage, this is a significant gap.

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

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

The description is front-loaded with the purpose statement, but then includes a verbose Args/Returns section that duplicates schema information. While this structure might help human readers, it adds redundancy for an AI agent that already has access to the schema. The core description is concise, but the overall text could be more streamlined.

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

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

For a complex mutation tool with 26 parameters and no annotations or output schema, the description is inadequate. It doesn't explain what the tool returns beyond 'TaskId' and '请求ID' (request ID), doesn't describe error conditions, doesn't provide usage examples, and doesn't clarify the operational context. The agent lacks crucial information to use this 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 the schema already documents all 26 parameters thoroughly with descriptions, defaults, and examples. The description adds no additional parameter information beyond what's in the schema, but since schema coverage is high, the baseline score of 3 is appropriate.

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

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

The description clearly states the action ('创建直播拉流任务' translates to 'Create live pull stream task') and identifies the resource (a streaming task). It distinguishes from siblings like 'delete_live_pull_stream_task' by specifying creation, but doesn't explicitly differentiate from other creation tools like 'create_live_transcode_rule' or 'create_live_transcode_template' in terms of when to use each.

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. The description doesn't mention prerequisites, constraints, or scenarios where this tool is appropriate compared to other streaming-related tools in the sibling list. 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 full burden. It states '创建' (create) which implies a write/mutation operation, but doesn't disclose behavioral traits like whether this requires specific permissions, if it's idempotent, what happens on failure, or if there are rate limits. The description only lists parameters and a return value without explaining the tool's behavior beyond the basic action.

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 appropriately sized and structured with clear sections for Args and Returns. It uses minimal text to convey the basic information, though the parameter section is redundant with the schema. No unnecessary elaboration or wasted sentences.

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

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

For a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what a 'live transcode rule' is, how it integrates with the system, what the '请求ID' (request ID) represents, or error conditions. Given the complexity of live streaming operations and lack of structured context, more explanation is needed.

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 parameters thoroughly. The description merely repeats the parameter names in Chinese without adding any additional meaning, examples, or context beyond what's in the schema. This meets the baseline for high schema coverage but doesn't provide 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 states '创建转码规则' (create transcode rule), which provides a basic verb+resource combination. However, it doesn't specify what type of transcode rule (e.g., live streaming, real-time encoding) or how it differs from sibling tools like 'create_live_transcode_template' or 'delete_live_transcode_rule'. The purpose is clear but lacks sibling differentiation.

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

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

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites, when this tool is appropriate, or what happens after creation. For example, it doesn't clarify if this should be used before or after creating a transcode template, or how it relates to other live streaming operations.

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 but provides minimal information. It states the tool creates something but doesn't mention whether this is a write operation requiring specific permissions, whether templates are immediately usable, what happens if creation fails, or any rate limits. The description only lists parameters without explaining the tool's behavior.

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

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

The description is extremely brief ('创建转码模板') followed by a parameter list. While concise, it's under-specified rather than efficiently informative. The parameter list is organized but adds little value since the schema already documents everything. The structure is functional but not optimized for understanding.

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

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

For a complex 22-parameter tool with no annotations and no output schema, the description is inadequate. It doesn't explain what a 'live transcode template' is, how it differs from rules, when templates are used, what the return values mean, or any prerequisites. The parameter list doesn't compensate for the lack of conceptual context.

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

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

Schema description coverage is 100%, so the schema already documents all 22 parameters thoroughly with ranges, defaults, and constraints. The description merely lists parameter names without adding meaningful semantic context beyond what's already in the schema. The baseline is 3 when schema coverage is complete.

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 '创建转码模板' (Create transcode template) is a tautology that restates the tool name without providing additional specificity. It doesn't distinguish this tool from sibling tools like 'create_live_transcode_rule' or explain what makes a 'live transcode template' different from other transcode-related 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?

The description provides no guidance on when to use this tool versus alternatives. There are multiple sibling tools related to live streaming and transcoding (create_live_transcode_rule, delete_live_transcode_template, etc.), but the description offers no context about when this specific template creation tool is appropriate versus other options.

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 states the tool deletes a domain, implying a destructive mutation, but lacks critical behavioral details: whether deletion is permanent/reversible, required permissions, rate limits, error conditions, or what '请求ID' (request ID) in returns signifies (e.g., async 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 brief and front-loaded with the main purpose ('删除域名'), followed by parameter and return sections. However, the Args/Returns formatting in Chinese is slightly redundant with the schema, and more context could be added without sacrificing conciseness.

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

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

For a destructive tool with no annotations and no output schema, the description is incomplete. It doesn't explain the return value ('请求ID') meaning, error handling, or safety considerations (e.g., confirmation prompts, dependencies). Given the complexity of deletion operations, more behavioral context is needed.

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%, providing clear parameter details (domain_name as string with example, domain_type as integer with values 0/1 explained). The description adds minimal value by listing parameters in Chinese but doesn't enhance semantics beyond the schema's thorough documentation.

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

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

The description clearly states the action ('删除域名' meaning 'delete domain') and specifies it's for live streaming domains, distinguishing it from non-live domain tools. However, it doesn't explicitly differentiate from sibling deletion tools like delete_live_pull_stream_task or delete_live_transcode_rule, 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?

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., domain must exist or be disabled), exclusions, or comparisons with sibling tools like forbid_live_domain (which might disable rather than delete).

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 states the action is a deletion (implying destructive), but doesn't mention critical behaviors: whether deletion is permanent/reversible, required permissions, rate limits, error conditions, or what happens to associated resources. The return value ('请求ID' meaning 'request ID') is noted but without context on how to use it.

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

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

The description is appropriately sized and front-loaded with the core purpose. The parameter list and return statement are structured but not overly verbose. However, the formatting with indentation and separate sections is slightly more structured than necessary for pure conciseness.

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

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

Given this is a destructive operation with no annotations and no output schema, the description is incomplete. It lacks behavioral details (safety, permissions), doesn't explain the return value's significance, and provides minimal usage context. For a 4-parameter deletion tool in a live streaming context, this leaves significant gaps for an AI agent.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description lists parameters but adds minimal semantics beyond the schema—it notes 'specify_task_id' is optional and provides Chinese translations, but doesn't explain interdependencies (e.g., when to use 'task_id' vs 'specify_task_id') or usage context. Baseline 3 is appropriate given high schema coverage.

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

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

The description clearly states the verb ('删除' meaning 'delete') and resource ('直播拉流任务' meaning 'live pull stream task'), making the purpose unambiguous. It distinguishes from siblings like 'delete_live_domain' or 'delete_live_transcode_rule' by specifying the exact resource type. However, it doesn't explicitly contrast with similar deletion tools in the sibling list.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., task must exist), exclusions, or relationships to sibling tools like 'describe_live_pull_stream_tasks' (which might list tasks before deletion) or 'create_live_pull_stream_task' (its counterpart). Usage is implied but not explicitly stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. While '删除' (delete) implies a destructive mutation, the description doesn't specify whether this requires special permissions, whether the deletion is permanent or reversible, what happens to associated resources, or any rate limits. For a destructive operation with zero annotation coverage, this is inadequate behavioral 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 brief with a clear purpose statement followed by Args/Returns sections. However, the structure is somewhat inefficient - the Args section essentially repeats parameter names without adding value beyond the schema. The single-sentence purpose statement is front-loaded but could be more informative about the tool's scope and impact.

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

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

For a destructive deletion tool with no annotations and no output schema, the description is incomplete. It doesn't explain what a 'transcode rule' is in this context, what the deletion affects, what the return value '请求ID' (request ID) represents, or error conditions. Given the complexity of live streaming systems and the lack of structured behavioral information, the description should provide more context.

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

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

The schema description coverage is 100%, so all parameters are documented in the input schema. The description lists the four parameters but adds no additional semantic context beyond what's already in the schema descriptions. It doesn't explain relationships between parameters or provide usage examples. With complete schema coverage, the baseline score of 3 is appropriate.

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

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

The description clearly states '删除转码规则' (delete transcode rule) which is a specific verb+resource combination. It distinguishes this tool from other deletion tools like delete_live_domain or delete_live_pull_stream_task by specifying it's for transcode rules. However, it doesn't explicitly differentiate from create_live_transcode_rule beyond the obvious delete/create distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., that a transcode rule must exist first), when deletion is appropriate, or what happens after deletion. With multiple sibling tools for managing live streaming resources, this lack of contextual guidance is a significant gap.

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

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

With no annotations provided, the description carries full burden but only states the action ('delete') without disclosing behavioral traits. It doesn't mention permissions required, whether deletion is permanent/reversible, side effects (e.g., impact on ongoing streams), or error handling, which is inadequate for a destructive operation.

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

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

The description is appropriately concise with a brief purpose statement and parameter/return notes. However, the structure could be improved by front-loading critical information (e.g., deletion implications) rather than burying details in a simple list.

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 of a deletion tool with no annotations, no output schema, and incomplete behavioral disclosure, the description is insufficient. It lacks details on what '请求ID' (request ID) means in returns, error cases, or confirmation of deletion success, leaving gaps for safe agent invocation.

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

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

The description adds minimal semantics by naming the parameter ('template_id: 模版ID'), but with 0% schema description coverage and only one parameter, this provides basic clarification. Since there are 0 parameters with schema descriptions, the baseline is 4, as the description compensates slightly by identifying 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 '删除转码模板' (delete transcode template) states the verb and resource clearly, but it's vague about what 'transcode template' refers to in this live streaming context. It doesn't differentiate from sibling tools like delete_live_transcode_rule, which suggests similar deletion operations on related 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?

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., template must exist), exclusions, or relationships to sibling tools like create_live_transcode_template or delete_live_transcode_rule, leaving usage context unclear.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tool queries information, implying a read-only operation, but doesn't specify if it requires authentication, has rate limits, returns real-time or cached data, or handles errors. For a tool with zero annotation coverage, this is a significant gap in 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 brief and structured with Args and Returns sections, making it easy to scan. However, it includes redundant information (e.g., '请求ID' - request ID is vague) and could be more front-loaded with key details. It's efficient but not perfectly optimized.

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 of live streaming domains and lack of annotations or output schema, the description is incomplete. It doesn't explain what 'DomainInfo' includes (e.g., status, settings, URLs) or the purpose of '请求ID', leaving the agent guessing about return values and operational context. This is inadequate for a tool in a domain with many siblings.

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

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

The schema description coverage is 100%, with the parameter 'domain_name' well-documented in the input schema (including an example). The description adds minimal value by restating the parameter name in Chinese without additional context, such as format constraints or domain types. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description states the tool '查询域名信息' (queries domain information), which provides a basic verb+resource combination. However, it lacks specificity about what type of domain information is retrieved (e.g., configuration, status, metadata) and doesn't distinguish itself from sibling tools like 'describe_live_domains' (plural) or 'describe_play_addr' (address description). The purpose is clear but vague in scope.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites, such as whether the domain must be enabled or configured, or differentiate from sibling tools like 'describe_live_domains' for listing multiple domains. The description only states what it does, not when to use it.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It only states it's a query/read operation and lists return fields, but doesn't mention authentication requirements, rate limits, pagination behavior beyond parameters, error conditions, or whether this affects system state. For a 7-parameter query tool with no annotation coverage, this is insufficient.

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

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

The description is structured with Args/Returns sections which is helpful, but includes redundant parameter documentation that duplicates the schema. The core purpose statement is only 4 characters ('查询域名列表'), making it overly terse. The return field documentation is useful but could be more efficiently integrated.

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

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

For a 7-parameter query tool with no annotations and no output schema, the description is incomplete. While it documents return fields, it doesn't explain the overall response structure, error handling, authentication needs, or how pagination works beyond the page_size/page_num parameters. The lack of output schema means the description should provide more complete return value documentation.

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 7 parameters thoroughly with descriptions, examples, and constraints. The description merely repeats parameter names without adding any additional semantic context, format details, or usage examples beyond what's in the schema. This meets the baseline for high schema coverage.

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

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

The description states '查询域名列表' (query domain list), which clearly indicates a read operation to retrieve domain information. However, it doesn't specify what type of domains (live streaming domains) or differentiate from similar siblings like 'describe_live_domain' (singular). The purpose is clear but lacks specificity about the resource scope.

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

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

No guidance is provided about when to use this tool versus alternatives. The sibling list includes 'describe_live_domain' (singular) and other describe_* tools, but the description doesn't explain when to use list vs. single domain queries, or how this relates to other domain management tools like add/delete/enable_live_domain.

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. While it mentions the tool queries tasks and describes return values, it doesn't disclose important behavioral traits like whether this is a read-only operation (implied but not stated), authentication requirements, rate limits, error conditions, or performance characteristics. The description provides basic functional information but lacks operational 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 reasonably structured with Args and Returns sections, but contains redundant information. The parameter explanations in the description are less detailed than those in the schema, making them somewhat wasteful. The Chinese-only text limits accessibility. While not excessively verbose, the description could be more efficiently integrated with the schema information.

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

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

For a query tool with 5 parameters and no output schema, the description provides basic functional coverage but lacks important context. It documents parameters and return values but doesn't explain the relationship between task_id and specify_task_id, doesn't mention pagination behavior beyond listing return fields, and provides no error handling information. With no annotations and no output schema, the description should do more to compensate for these gaps.

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

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

The description lists all 5 parameters with brief explanations, but the input schema already has 100% description coverage with more detailed documentation (including defaults, examples, and constraints). The description adds minimal value beyond what's already in the schema - it essentially repeats parameter names with less detail. With complete schema coverage, the baseline score of 3 is appropriate as the description doesn't significantly enhance parameter understanding.

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

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

The description clearly states the tool's purpose as '查询直播拉流任务' (query live pull stream tasks), which is a specific verb+resource combination. It distinguishes itself from siblings like 'create_live_pull_stream_task' (create) and 'delete_live_pull_stream_task' (delete) by focusing on querying/describing existing tasks. However, it doesn't explicitly differentiate from other 'describe_' tools in the sibling list.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when this query tool should be used instead of other describe tools (like describe_live_domain or describe_live_stream_state), nor does it provide any context about prerequisites or typical usage scenarios. The parameter documentation implies query capabilities but offers no strategic guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. While it mentions the tool queries inferred stream events and lists parameters, it doesn't describe important behavioral aspects: whether this is a read-only operation, what permissions might be required, whether there are rate limits, what happens if parameters are omitted, or how errors are handled. The description provides basic functional information but lacks crucial operational 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 efficiently structured with a brief purpose statement followed by parameter and return value documentation. While the Chinese text could be more concise, it follows a clear format with Args and Returns sections. Every sentence serves a purpose, though the initial purpose statement could be more informative.

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

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

For a query tool with 10 parameters and no annotations or output schema, the description is insufficient. It doesn't explain what 'inferred stream events' are, what the EventList contains, how pagination works in practice, or what format the response takes. The lack of output schema means the description should explain return values more thoroughly, but it only lists names without context.

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

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

The schema description coverage is 100%, meaning all parameters are well-documented in the input schema itself. The description lists parameters but adds minimal semantic value beyond what's already in the schema descriptions. It doesn't explain relationships between parameters (e.g., how start_time and end_time work together) or provide usage examples. Given the high schema coverage, the baseline score of 3 is appropriate.

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

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

The description states '查询推断流事件' (query inferred stream events), which provides a basic purpose but is vague. It doesn't clearly differentiate this from sibling tools like 'describe_live_stream_online_list' or 'describe_live_stream_state', nor does it specify what 'inferred stream events' actually means. The description lacks specificity about what resource is being queried beyond the general concept of stream events.

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 about when to use this tool versus alternatives. The description doesn't mention any prerequisites, context for usage, or comparisons with sibling tools like 'describe_live_stream_online_list' or 'describe_live_stream_state'. The agent receives no help in determining when this specific query tool is appropriate versus other describe tools in the system.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool returns '正在直播中的流列表' (list of live streams), which implies a read-only operation, but doesn't address critical behaviors like pagination handling (implied by page_num/page_size but not explained), rate limits, authentication needs, error conditions, or response format details. For a tool with 5 parameters and no annotation coverage, this is inadequate.

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: a brief purpose statement followed by Args and Returns sections. However, the Args section merely lists parameter names without adding meaningful context, and the Returns section is vague ('正在直播中的流列表' doesn't specify structure). It's efficient but could be more informative with less 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 5 parameters, no annotations, and no output schema, the description is incomplete. It lacks behavioral details (e.g., pagination mechanics, error handling), usage guidance relative to siblings, and specifics on the return value format. For a query tool with filtering and pagination, this leaves significant gaps for an agent to invoke it correctly without additional context.

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

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

Schema description coverage is 100%, with detailed parameter descriptions in the input schema (e.g., defaults, examples, constraints like page_size max 100). The tool description lists parameters in Args but adds minimal semantic value beyond restating names. It doesn't explain interactions between parameters (e.g., how app_name, domain_name, and stream_name filter results together) or provide usage examples. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose: '查询直播中的流' (query live streams). It specifies the resource (live streams) and verb (query/list), which is specific and actionable. However, it doesn't explicitly differentiate from siblings like 'describe_live_stream_state' or 'describe_live_stream_event_list', which reduces clarity about when to choose this tool over those alternatives.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'describe_live_stream_state' (which might check individual stream status) or 'describe_live_stream_event_list' (which might list stream events), leaving the agent to guess based on names alone. There's no context about prerequisites, typical use cases, or exclusions.

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

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

No annotations are provided, so the description carries full burden. It only states it queries status without disclosing behavioral traits like whether it's read-only, requires authentication, has rate limits, or what happens on errors. For a tool with no annotations, this leaves critical operational details unspecified.

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 brief but structured with Args and Returns sections, which is helpful. However, it includes redundant parameter listings that add little beyond the schema, and the core description '查询流状态' is overly terse, lacking necessary context. It's efficient but under-specified.

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 annotations and no output schema, the description is incomplete. It doesn't explain what '流状态' (stream status) returns, such as data format or possible values, nor does it cover error handling or dependencies. For a query tool with three parameters, this leaves too much ambiguity for effective use.

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%, providing full parameter documentation. The description adds minimal value by listing parameters in an Args section, but doesn't explain semantics beyond what the schema already covers, such as interdependencies or usage examples. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description states '查询流状态' (query stream status), which provides a basic verb+resource but is vague about what 'stream status' entails. It doesn't differentiate from siblings like 'describe_live_stream_online_list' or 'describe_live_stream_event_list', leaving the specific scope unclear. The purpose is identifiable but lacks precision.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites, context, or exclusions, such as how it differs from other 'describe' tools for streams. The agent must infer usage from the name alone, which is insufficient for informed selection.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While it mentions the return values (PushAuthKeyInfo, RTMPAddr, 请求ID), it doesn't describe whether this is a read-only operation, what permissions are needed, whether it has side effects, rate limits, or error conditions. The description provides output information but lacks important behavioral context for a tool 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 efficiently structured with a brief purpose statement followed by Args and Returns sections. While the Chinese/English mix could be cleaner, the information is well-organized and front-loaded. The Args/Returns formatting helps with readability despite the language inconsistency.

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, 100% schema coverage, but no annotations and no output schema, the description provides basic purpose and return value information. However, it lacks important context about when to use this versus sibling tools, behavioral characteristics, and deeper parameter relationships. The return value descriptions are helpful but incomplete without an output schema.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description lists parameters but doesn't add meaningful semantic context beyond what's in the schema. It correctly identifies optional parameters but doesn't explain relationships between parameters or provide usage examples that go beyond schema documentation.

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

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

The description states the purpose as '获取播放地址' (get playback address), which is a clear verb+resource combination. However, it doesn't distinguish this from sibling tools like 'describe_rtmp_addr' or explain what makes this specific playback address retrieval different from other describe/retrieval tools in the list.

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

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

No guidance is provided about when to use this tool versus alternatives. The description doesn't mention when this specific playback address retrieval is appropriate compared to other describe tools or the sibling 'describe_rtmp_addr' tool. There's no context about prerequisites or typical use cases.

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. While it mentions the tool retrieves RTMP addresses and auth key information, it doesn't disclose important behavioral aspects: whether this is a read-only operation, authentication requirements, rate limits, error conditions, or what happens when parameters are invalid. The description is minimal beyond basic functionality.

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 reasonably concise with a clear purpose statement followed by Args and Returns sections. However, the formatting with indentation is inconsistent, and the Returns section lists data types without explaining what they contain or their significance. The structure is functional but could be more polished.

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

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

Given no annotations, no output schema, and a tool that retrieves authentication-sensitive streaming addresses, the description is incomplete. It doesn't explain the security implications of the returned auth key, how the RTMP address should be used, or what format the response takes. For a tool dealing with streaming infrastructure and authentication, more context is needed.

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 parameters thoroughly with descriptions, examples, and defaults. The description's Args section merely repeats parameter names without adding meaningful semantic context beyond what's in the schema. This meets the baseline 3 for high schema coverage.

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

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

The description clearly states the tool's purpose as '获取推流地址' (get RTMP push address), which is a specific verb+resource combination. It distinguishes itself from siblings like 'describe_play_addr' (which likely retrieves playback addresses) by focusing on push/streaming addresses rather than playback. However, it doesn't explicitly differentiate from all siblings, just implies a different address type.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, when this tool is appropriate versus other describe_* tools, or any exclusions. The agent must infer usage from the tool name and description alone without explicit 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 provided, the description carries the full burden of behavioral disclosure. While '断开' (disconnect) implies a destructive action, the description doesn't clarify whether this is reversible, what permissions are required, whether it affects viewers, or what happens to the stream data. This is a significant gap for a mutation tool.

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

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

The description is efficiently structured with a clear purpose statement followed by parameter and return documentation. Every sentence serves a purpose, though the parameter listing could be more integrated with the main description.

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

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

For a destructive operation with no annotations and no output schema, the description is inadequate. It doesn't explain what '断开' actually means operationally, what the request ID represents, or what side effects occur. The agent lacks crucial context to use this tool safely and effectively.

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

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

Schema description coverage is 100%, so the schema already fully documents all three parameters. The description lists the parameters but adds no additional meaning beyond what's in the schema descriptions. This meets the baseline for high schema coverage.

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

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

The description clearly states the action ('断开直播流' - disconnect live stream) and resource (live stream), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'forbid_live_stream' or 'resume_live_stream', which prevents a perfect score.

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 'forbid_live_stream' or 'resume_live_stream'. There's no mention of prerequisites, consequences, or appropriate contexts for disconnecting a live stream.

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. '启用域名' implies a write/mutation operation (changing domain state to enabled), but it doesn't specify what 'enabling' actually does (e.g., makes domain available for live streaming, requires specific permissions, may have propagation delays). It mentions a return value ('请求ID' - request ID) which suggests an asynchronous operation, but doesn't explain what this ID is for or how to track completion. For a mutation tool with zero annotation coverage, this is inadequate.

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 brief (three lines) but poorly structured. The first line '启用域名' is under-informative, while the Args/Returns sections are formatted but add little beyond what's in the schema. The description feels incomplete rather than efficiently concise - it wastes the opportunity to provide meaningful context in its limited space.

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

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

For a mutation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what 'enabling' a live domain entails operationally, what state changes occur, potential side effects, or how to use the returned request ID. Given the sibling tools include both 'add_live_domain' and 'forbid_live_domain', the description should clarify this tool's specific role in the domain lifecycle management.

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

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

Schema description coverage is 100%, with the parameter 'domain_name' well-documented in the schema (including example value and clear title). The description adds minimal value by labeling it '推流域名' (push streaming domain) which provides slightly more context than the schema's '域名名称' (domain name), but this is marginal. With high schema coverage, the baseline score of 3 is appropriate as the schema does most of the work.

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

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

The description '启用域名' (Enable domain) is a tautology that essentially restates the tool name 'enable_live_domain' in Chinese. While it indicates the action is enabling something related to domains, it doesn't specify what type of domain (live streaming domain) or what 'enabling' entails operationally. It fails to distinguish this tool from sibling tools like 'add_live_domain' or 'forbid_live_domain' which also manipulate domains.

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 absolutely no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., domain must exist, be in a disabled state), nor does it differentiate from similar tools like 'add_live_domain' (create new) or 'forbid_live_domain' (disable). The agent receives no contextual cues about appropriate usage scenarios.

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

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

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It states the action is 'disable' but doesn't clarify if this is reversible, requires specific permissions, affects ongoing streams, or has side effects. For a mutation tool with zero annotation coverage, this is insufficient disclosure.

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 brief and structured with Args/Returns sections, but the core description '禁用域名' is overly terse. It efficiently states the action and parameter, though it could benefit from a slightly more explanatory opening sentence 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?

For a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what 'disable' means operationally, what the return value '请求ID' (request ID) implies (e.g., for async tracking), or error conditions. Given the complexity of domain management and sibling tools, more context is needed.

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

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

Schema description coverage is 100%, so the schema already documents the 'domain_name' parameter with an example. The description adds no additional meaning beyond restating the parameter name in Chinese ('推流域名' - push stream domain), which slightly clarifies it's for live streaming domains but doesn't provide format constraints or validation rules beyond the schema.

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

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

The description states '禁用域名' (disable domain) which provides a basic verb+resource, but it's vague about what type of domain and what 'disable' entails. It doesn't distinguish from siblings like 'delete_live_domain' or 'enable_live_domain', leaving ambiguity about whether this is a temporary deactivation or permanent removal.

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 'delete_live_domain' or 'enable_live_domain'. The description lacks context about prerequisites, consequences, or typical use cases, leaving the agent with no usage differentiation from sibling tools.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While '禁推' (forbid) implies a destructive/mutative action, the description doesn't clarify what 'forbid' actually means operationally - whether it stops streaming immediately, blocks future streams, requires specific permissions, or has irreversible consequences. The optional 'resume_time' parameter suggests this might be temporary, but this isn't explicitly stated in the description.

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

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

The description is efficiently structured with a clear purpose statement followed by Args/Returns sections. However, the purpose statement is overly terse ('禁推直播流' - just three characters in Chinese) and could benefit from slightly more elaboration about what 'forbid' entails. The structure is good but could be more informative in the opening statement.

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

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

For a destructive/mutative tool with no annotations and no output schema, the description is insufficient. It doesn't explain what the tool actually does operationally, what permissions are required, what the consequences are, or what the return value '请求ID' (request ID) represents. The description leaves critical behavioral questions unanswered for a tool that appears to modify live streaming state.

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

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

Schema description coverage is 100%, so the schema already fully documents all 5 parameters. The description lists parameters but adds no additional semantic context beyond what's in the schema. The baseline score of 3 is appropriate when the schema does all the parameter documentation work.

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

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

The description clearly states the tool's purpose as '禁推直播流' (forbid live stream), which is a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'drop_live_stream' or 'forbid_live_domain', which appear to be related stream management operations. The purpose is clear but lacks sibling differentiation.

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

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

The description provides no guidance about when to use this tool versus alternatives like 'drop_live_stream' or 'resume_live_stream'. There's no mention of prerequisites, consequences, or typical use cases. The only implied usage is through the parameter descriptions, but no explicit guidance 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 carries full burden. It states the action ('取消直播延时') but lacks behavioral details: whether this requires specific permissions, if it's reversible, what happens to the stream (e.g., goes live immediately), rate limits, or side effects. For a mutation tool with zero annotation coverage, this is insufficient.

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

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

The description is brief and front-loaded with the purpose ('取消直播延时'), followed by parameter and return sections. However, the parameter listing is redundant with the schema, and the return statement ('请求ID') is vague without context. It could be more efficient by omitting the Args/Returns boilerplate.

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

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

For a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what '取消直播延时' entails behaviorally, what '请求ID' means (e.g., for tracking), error handling, or dependencies. Given the complexity of live streaming operations, more context is needed for safe use.

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

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

Schema description coverage is 100%, with each parameter well-documented in the schema (e.g., '推流路径，与推流和播放地址中的AppName保持一致'). The description lists parameters but adds no meaning beyond the schema—it doesn't explain relationships between parameters or usage context. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description '取消直播延时' (cancel live stream delay) clearly states the verb (cancel) and resource (live stream delay). It distinguishes from sibling tools like 'add_delay_live_stream' (add delay) and 'resume_live_stream' (resume stream without specifying delay). However, it doesn't explicitly mention what type of delay is being canceled (e.g., buffer delay vs. scheduled delay), which prevents a perfect score.

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. It doesn't specify prerequisites (e.g., must have an active delayed stream), contrast with 'resume_live_stream' (which might resume without affecting delay), or mention error conditions. The agent must infer usage from the name alone.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states the action ('resume') but doesn't explain what 'resume' means operationally (e.g., does it restart streaming, restore permissions, or something else?), what permissions are required, whether it's idempotent, or what happens on failure. The return value '请求ID' (request ID) is mentioned but not explained. Significant behavioral gaps exist.

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 brief and structured with clear sections for Args and Returns. However, the single-sentence purpose statement '恢复直播流' is somewhat terse and could benefit from slightly more context about what 'resume' entails. No wasted text, but slightly under-specified.

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 annotations and no output schema, the description is incomplete for a mutation tool. It doesn't explain the behavioral implications of 'resume' (e.g., side effects, error conditions), the meaning of the return value, or how this tool relates to siblings like 'forbid_live_stream'. For a tool that likely changes system state, this leaves critical gaps.

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

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

Schema description coverage is 100%, with each parameter well-documented in the input schema (e.g., 'stream_name' has description '流名称。示例值：stream1'). The description lists the three parameters but adds no meaningful semantics beyond what the schema already provides. This meets the baseline of 3 when schema coverage is high.

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

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

The description states the tool's purpose as '恢复直播流' (resume live stream), which is a clear verb+resource combination. However, it doesn't differentiate from sibling tools like 'resume_delay_live_stream' or 'forbid_live_stream', leaving ambiguity about when to use this specific resume operation versus alternatives.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., the stream must be in a forbidden state), compare to sibling tools like 'resume_delay_live_stream', or indicate when this tool would be inappropriate. The agent receives no usage context.

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