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

With no annotations, the description must disclose behavioral impact. It states the tool clears the trace log, implying a destructive action, and explains the purpose of obtaining clean logs for the next Inform. It does not mention irreversibility or side effects, but the verb '清空' is sufficiently explicit for this simple 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 sentence that is concise and front-loaded with the primary action. Every part contributes useful information: the action, the resource, and the usage sequence. No wasted words.

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

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

For a zero-parameter, no-output-schema tool, the description is complete. It explains what the tool does, why it is useful, and the exact sequence of usage with related tools. No additional information is needed for an agent to correctly select and invoke it.

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

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

The tool has zero parameters, so the input schema is empty. The description adds context beyond the schema by explaining the intended workflow and association with acs_connection_request. Baseline for zero parameters is 4, and the description meets this.

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 ('清空' = clear) and the specific resource ('trace.log'), distinguishing it from sibling tools like acs_get_trace_log which reads the log. It unambiguously identifies the tool's function.

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

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

The description explicitly provides a usage workflow: '先清空 → 发 CR → 再查看 trace.log' (clear first, then send connection request, then view log). This tells the agent exactly when to use this tool and its role relative to acs_connection_request and acs_get_trace_log.

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 states the action but does not disclose potential side effects (e.g., device state changes), prerequisites (e.g., device online), authentication requirements, or the expected response. This is a minimal description that misses important 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?

The description is a single, front-loaded sentence with no filler or redundant information. It is concise and efficient, earning a high score for structure.

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

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

Given the complexity of 4 optional parameters and no output schema or annotations, the description is too minimal. It does not explain how to choose between this tool and 'acs_connection_request_current', nor does it clarify the expected outcome or failure modes. The all-optional parameters and lack of guidance make it incomplete for an agent to use confidently.

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

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

The input schema has 100% parameter description coverage, so the baseline is 3. The tool description does not add any extra parameter semantics beyond what the schema already provides, but it also does not need to since the schema is comprehensive.

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 ('Send Connection Request') and the target ('device'), and implies the purpose of triggering a connection to ACS. However, it does not explicitly distinguish this tool from the sibling 'acs_connection_request_current', which likely targets the current device, so it 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. It does not mention preconditions, target selection criteria, or that 'acs_connection_request_current' exists for the current device. The usage context is only implied by the action itself.

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 states the action but does not disclose potential side effects, authentication requirements, whether the request is asynchronous, or what the response looks like. For a mutation-like tool, this is a significant gap.

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

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

The description is a single simple sentence that directly conveys the core functionality. It is front-loaded and contains no extraneous information, earning the full score for 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 the tool's low complexity (no parameters, no output schema), the description is minimally sufficient for invocation. However, it lacks context about return values or behavioral details that an agent would need to interpret the result, making it merely adequate.

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

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

The tool has zero parameters, so the baseline is 4. The description adds no parameter details because none exist, and the schema already covers 100% of the (empty) parameter space.

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 '向 Current.json 中的当前设备发送 Connection Request' clearly states the action (send Connection Request) and the target resource (current device in Current.json). It distinguishes itself from the sibling 'acs_connection_request' by explicitly scoping to the current device.

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 that acs_connection_request is for a specified device, nor any prerequisites or context. The usage context is only implied by the name and target.

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. As a mutation tool, it does not disclose whether an existing script is overwritten, what happens on update, whether specific permissions are needed, or what the return value represents. This is a significant gap for an upsert 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 short sentence with no redundancy. It is maximally concise and front-loaded, though more detail could be added, the structure itself is efficient.

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

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

For a simple mutation tool with no output schema and no annotations, the description is too sparse. It lacks critical behavioral details like idempotency, overwrite semantics, and expected response, making it incomplete for an agent to fully understand the tool's operation.

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

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

Schema description coverage is 100% for both parameters (name and content). The description adds no extra semantic detail beyond the schema, such as uniqueness constraints or content validation rules. Baseline 3 applies when schema covers everything.

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 '创建或更新一个 TR-069 Lua 脚本' clearly states a create/update action on a specific resource (TR-069 Lua script). It distinguishes from sibling tools like acs_get_script, acs_delete_script, and acs_run_script by indicating write 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?

No guidance is provided on when to use this tool versus alternatives such as acs_list_scripts, acs_get_script, or acs_update_script. There are no exclusions or alternative tool mentions, leaving the agent to 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 of behavioral disclosure. It states the core delete action but does not disclose irreversibility, dependencies, permissions, or side effects. Without annotations, this is insufficient for an agent to understand the impact of calling this 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, clear sentence with no extraneous words. It is front-loaded with the action and resource, making it efficient and easy to parse.

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

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

Given the simplicity of the tool (one parameter, no output schema, no annotations), the description is minimally adequate. However, it omits important context such as whether the script must exist, if deletion is reversible, or any edge cases. For a basic delete operation, this is acceptable but not 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 description coverage is 100% (the parameter 'name' is described as '脚本文件名'). The description adds no extra meaning beyond the schema, so a baseline score of 3 is appropriate. The action of deleting inherently implies the target, but the schema already covers the parameter 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 action (delete) and the resource (TR-069 script), distinguishing it from sibling tools such as acs_create_script, acs_get_script, and acs_list_scripts. It uses a specific verb and resource, leaving no ambiguity about what the tool does.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention any preconditions, scenarios, or exclusions. It lacks context for selecting this tool among the many script-related siblings.

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

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

With no annotations, the description carries the full burden. It discloses that it automatically starts an HTTP server and uses TR-069 Download RPC, which is useful behavioral context. However, it doesn't mention potential side effects like device reboot or config replacement, and the return result is vague.

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

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

The description is concise—two sentences total—with the main purpose front-loaded. Every sentence adds value: the first explains the mechanism, the second clarifies the optional sn parameter. 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?

The description gives the high-level workflow but lacks critical details. There is no output schema, so the description should explain the return value format, but it only says '返回结果' (return result). It also omits any warnings about config deployment consequences or the fileType parameter, even though it's in the schema. This is insufficient for a tool that deploys configs.

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 baseline is 3. The description adds minimal extra meaning beyond the schema: it restates the file path requirement and the sn fallback, both already in the schema. It doesn't mention fileType at all, so the description adds little over the structured input.

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: '一键下发配置文件到设备' (one-click deploy config file to device), and details the mechanism (start HTTP server, TR-069 Download RPC). This distinguishes it from sibling tools like acs_upload_config or acs_download_config by specifying the TR-069 deployment flow.

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—deploying a local .cfg file to a device via TR-069—but does not explicitly contrast with alternatives like acs_push_config or acs_upload_config. The fallback behavior for sn is mentioned, but no when-to-use 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?

With no annotations, the description carries the burden of behavioral disclosure. It explains that the device will download the file from the given URL and warns about accessibility, which is useful. However, it does not disclose authentication requirements, whether the operation is synchronous, or what happens on failure, leaving 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 two sentences, front-loaded with the core action and followed by a relevant warning. Every sentence earns its place, and there is no redundant filler.

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

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

The description is minimally sufficient for a straightforward RPC: it names the protocol and the URL constraint. However, given no output schema and no mention of response behavior or when to use this vs. sibling tools, the context is not fully complete.

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

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

The input schema already provides 100% parameter descriptions. The description's warning about fileUrl essentially echoes the schema's own note ('HTTP/HTTPS，设备可访问'), so it adds no new semantic value beyond what the schema already provides.

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

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

The description clearly states the tool's function: delivering a configuration file to a device via TR-069 Download RPC. It specifies the mechanism ('设备会从 fileUrl 下载文件') and differentiating it from sibling tools that may use push or deploy methods, making the purpose unambiguous.

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

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

The description provides a critical usage constraint: fileUrl must be an HTTP/HTTPS URL accessible by the device, not a local ACS path. However, it does not explicitly state when to prefer this tool over alternatives like acs_push_config or acs_deploy_config, nor does it 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 bears full responsibility for disclosing behavioral traits. It states that the tool executes raw shell commands, but does not warn about the significant risks (e.g., potential damage to the server, missing safety checks, or required permissions). The 'advanced debugging' caveat is the only implicit warning, which is insufficient for a high-risk mutating 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, front-loaded sentence that conveys the essential action and purpose without extraneous words. This is appropriately concise for a tool with minimal parameters, and no important information is buried.

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

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

Given the high complexity and risk of a raw shell command execution tool, the description is severely underspecified. It lacks any mention of return behavior, potential side effects, prerequisites, or whether the command runs on the server itself rather than connected devices. With no output schema and no annotations, this minimal description leaves major gaps for safe and correct usage.

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

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

The input schema covers both parameters (command and timeout) with descriptions, achieving 100% coverage. The description itself adds no parameter-specific semantics, but the schema provides sufficient baseline meaning, so a score of 3 is appropriate as per calibration.

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 ('execute raw shell commands') and the target ('on the ACS server'), with a purpose ('for advanced debugging'). This distinguishes it from sibling tools like acs_run_script which focus on predefined scripts, and acs_status which is read-only.

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

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

The phrase '用于高级调试' (for advanced debugging) provides a clear usage context, implying it is not for routine operations. However, it does not explicitly name alternatives or exclusion criteria, so it falls short of full guidance.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only states a lookup action, giving no information about read-only guarantees, error behavior for missing SN, or return format. This leaves significant gaps for a tool that might be used in automated workflows.

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 immediately conveys the core purpose. There is no wasted information 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 lookup tool with one parameter and no output schema, the description is minimally adequate but lacks details on what 'device information' includes or what happens when the SN is not found. Given the lack of an output schema, more specificity 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?

The schema already provides a clear description of the 'sn' parameter with an example. The description adds that the device is found 'based on SN', but this is largely redundant with the schema. Since schema coverage is 100%, the baseline of 3 is appropriate; the description does not 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 a specific action ('根据 SN 查找') and resource ('设备信息'), making it distinct from siblings like list_devices or get_current_device. The SN parameter is prominently featured, leaving no ambiguity about the tool's core function.

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

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

The description implies usage: use this when you have an SN and need device information. However, it does not explicitly mention when not to use it or provide alternatives, leaving the agent to infer context from the tool name and sibling list.

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

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

No annotations are provided, and the description only states 'get boot log' without disclosing any behavioral traits such as read-only nature, output format, or side effects. The description carries the full burden for transparency and fails to provide meaningful details 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 with no fluff, and it is front-loaded with the action. However, it is almost a direct translation of the tool name and could include a bit more context without becoming verbose, so a slight deduction applies.

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

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

With no annotations, no output schema, and only one optional parameter, the description is sparse. It does not explain what the boot log contains, whether it requires a device selection, or how it differs from trace/error logs. For a tool with many siblings, this missing context 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?

The schema has 100% coverage for the single optional 'lines' parameter, with its own description '返回最后 N 行' (returns last N lines). The tool description adds no parameter semantics, so baseline 3 is appropriate since the schema already handles the burden.

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 '获取 ACS boot 日志' clearly states the action (get) and the resource (ACS boot log), which distinguishes it from sibling tools like acs_get_trace_log and acs_get_error_log. The verb+resource specificity fully clarifies the tool's purpose.

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

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

The description provides no guidance on when to use this tool versus the many sibling log tools, nor does it mention any prerequisites such as requiring a connected device. There is no context about whether this is for the server or a device, leaving the agent without direction.

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

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

No annotations are provided, so the description carries full burden. It discloses a meaningful behavioral trait by stating that the password is masked (脱敏) and enumerates the returned fields. However, it does not explicitly confirm read-only behavior or mention whether any authentication is required, though the verb '获取' implies a safe read.

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 in Chinese that front-loads the action and clearly specifies the resource and key details. Every word contributes meaning, 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?

For a zero-parameter configuration getter, the description provides a useful preview of the returned data, including the masked password. It lacks an output schema, but the description compensates reasonably. It could mention error cases or the response format, but these are not critical for such a simple tool.

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

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

The tool has zero parameters and an empty schema, so the baseline is 4 per the rubric. The description adds value by outlining the output fields (host, port, username, acsBasePath, masked password), even though that relates to output rather than 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 tool retrieves the current ACS MCP Server connection configuration, listing specific fields (host/port/username/acsBasePath) and noting password masking. This distinguishes it from sibling tools like acs_get_parameters or acs_get_script that 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 for viewing server connection settings but provides no explicit guidance on when to choose this tool over alternatives. It does not mention exclusions or contrast with related sibling tools, leaving some ambiguity for an agent.

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

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

With no annotations provided, the description carries the full burden. It adds the useful detail that data comes from Current.json and implies a read-only operation. However, it does not disclose potential failure modes (e.g., what happens if no current device exists) or any side effects, leaving some behavioral ambiguity.

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

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

The description is a single concise sentence that front-loads the essential information. Every word contributes to the understanding, with no filler or redundancy.

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

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

For a zero-parameter getter with a clear name, this description is adequate. It specifies the data source and the object of interest. However, it doesn't describe the return value's structure or content (e.g., which device fields are included), which could be helpful but is not critical given the tool's simplicity.

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

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

The tool has zero parameters, so the schema is complete. The description correctly implies no inputs are needed, and there is nothing to clarify beyond that. Baseline of 4 applies.

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

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

The description clearly states the tool's function: to get the current device information being processed, sourced from Current.json. This specific verb+resource combination distinguishes it from siblings like acs_list_devices (which lists all devices) and acs_find_device (which searches for a specific device).

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. There is no mention of contexts where this should be preferred over acs_status or acs_list_devices, nor any exclusions.

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

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

No annotations are present, and the description only states the basic action without disclosing any behavioral traits. It does not mention that the tool returns the last N lines (implied by the 'lines' parameter), nor any side effects, permissions, or output format.

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

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

The description is extremely short, which is concise, but it lacks structure and fails to include necessary context. It is not verbose, but it is under-specified, earning a middle score.

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

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

With no output schema and no annotations, the description carries the full burden of explaining the tool's behavior. The one-line description is inadequate; it omits return format, the effect of the 'lines' parameter, and any operational 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 fully describes the single 'lines' parameter as '返回最后 N 行' (return last N lines). The description adds no additional meaning beyond this, so the baseline score of 3 applies.

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

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

The description clearly states the action (获取/get) and the resource (ACS error log). It distinguishes from sibling tools like acs_get_boot_log and acs_get_trace_log by specifying 'error' log specifically.

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 vs alternatives like boot log or trace log. There is no mention of context, prerequisites, or exclusions.

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

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

No annotations are provided, so the description carries full burden. It does disclose the mechanism (calls GetParameterValues via a temporary script), which implies a read operation and transient artifact creation. However, it omits cleanup behavior, error conditions, and return format details.

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

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

The description is a single, front-loaded sentence with no wasteful words. The main purpose comes first, with implementation detail in parentheses, achieving maximum clarity in minimal 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?

With no output schema and no annotations, the description should explain what the agent receives or any limitations, but it only states the mechanism. It does not describe the return format, distinguish from similar tools like acs_get_config, or mention edge cases, leaving critical gaps for a 2-parameter get operation.

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

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

Schema description coverage is 100% for both parameters (sn and paramPath) with examples and context already provided. The tool description adds no new parameter semantics beyond noting the temporary-script mechanism; baseline 3 is appropriate since the schema handles the explanation.

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 starts with '获取设备参数值' (get device parameter values), a specific verb+resource combination that clearly states what the tool does. The parenthetical '通过临时脚本调用 GetParameterValues' adds implementation detail and distinguishes it from siblings like acs_set_parameters.

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

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

The description implies usage for reading device parameter values but does not explicitly state when to use this tool versus alternatives like acs_get_config or acs_exec_raw. No exclusions or alternative guidance are provided, so the agent must infer usage from the name and mechanism.

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's verb '获取' (get) indicates a read-only operation. However, it does not disclose potential side effects, error conditions, or authentication requirements. This is adequate for a simple getter but lacks deeper 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 a single concise sentence with no redundant information, fully front-loaded and easy to parse.

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 well-documented parameter and no output schema—the description sufficiently covers what it does. It could mention the return format or prerequisites, but for a simple list-returning getter, it is almost complete.

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

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

The schema already describes the 'sn' parameter as '设备序列号' (device serial number) with 100% coverage. The description does not add any additional meaning beyond the schema, so the baseline of 3 applies.

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

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

The description clearly states the tool's function: '获取设备支持的 RPC 方法列表' (get the list of RPC methods supported by the device), using a specific verb and resource. It is distinct from sibling tools like acs_get_parameters or acs_get_script, which target different resource types.

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 any prerequisites, such as device connectivity, or contrast it with other similar tools. The sibling list is provided but not referenced.

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 only states 'view content' with no mention of return format, error behavior, side effects, or prerequisites. This is a significant gap for a tool that could involve network calls or device access.

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. It is front-loaded and every word contributes to the meaning.

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

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

This is a low-complexity tool with one well-documented parameter and no output schema. The description adequately conveys the core purpose, though it could benefit from noting what the tool returns or whether it reads from a local store vs. device. Still, given the simplicity, it is reasonably complete.

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

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

Schema description coverage is 100% with the 'name' parameter described as a script file name (e.g., Bootstrap.lua). The description adds minimal meaning beyond the schema by referencing 'specified script', but does not provide additional semantic details about 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 (查看/view) and resource (script content), clearly distinguishing it from siblings like list_scripts (list all), create_script, delete_script, and run_script. It precisely states the action and target.

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: use this tool when you need to view a specific script's content. It does not explicitly mention alternatives or exclusions, but the context is clear from the tool name and sibling list. Lacks explicit 'when not to use' guidance, so not a 5.

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

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

No annotations are provided, and the description does not disclose side effects, return format, or read-only status beyond the verb 'get'. It merely renames the resource, leaving the agent to infer 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 a single, front-loaded sentence with no superfluous information.

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

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

For a zero-parameter getter, the description adequately communicates the task, but it could explicitly state that it returns the contents of seq.txt or is a safe read operation.

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

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

The tool accepts no parameters, and the schema coverage is complete; the baseline score of 4 applies.

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

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

The description clearly states the action (获取/Get) and the resource (当前脚本执行序列/current script execution sequence), and distinguishes it from sibling tools like acs_set_sequence by focusing on retrieval.

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 retrieving the current script execution sequence, but provides no explicit guidance on when to use this versus alternatives like acs_set_sequence or acs_get_script.

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, leaving the description as the sole source of behavioral disclosure. The description provides only the basic 'get' action, with no details on return format, side effects (e.g., whether the log is cleared), pagination, or security considerations. This is inadequate for full transparency.

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

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

The description is a single, focused sentence with no redundancy. It is concise and to the point, but the extreme brevity limits the information conveyed. It earns a 4 because it is efficient, though it could benefit from slightly more context 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 tool has no output schema, no annotations, and only a minimal description. It does not explain what a 'trace log' is, what the output structure looks like, or how it relates to sibling log tools. For a tool with a single optional parameter, the description feels incomplete and leaves many context 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 input schema contains one parameter ('lines') with a description ('返回最后 N 行'), giving 100% coverage. The tool description adds no additional meaning about the parameter. Per the baseline rule for high schema coverage, 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 '获取 ACS trace 日志' clearly states the action (get) and resource (ACS trace log). It is specific enough to identify the tool's purpose, but it does not explicitly differentiate it from sibling tools like acs_get_boot_log or acs_get_error_log, which share the same structure. Therefore, it stops short of a 5.

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

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

No guidance is provided on when to use this tool vs alternatives. The description does not mention any scenario, precondition, or exclusion. There is no reference to other log-related tools, so an agent has no basis for choosing this over acs_get_boot_log or acs_get_error_log.

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

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

No annotations are provided, so the description must carry the behavioral disclosure burden. The verb 'list' implies a read-only operation, but the description does not explicitly state that there are no side effects, permissions required, or other behavioral nuances. It adds some context by naming the data source (DeviceList.json), but stops short of full transparency about safety or 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 a single sentence that efficiently conveys the tool's purpose and the specific output fields. It is front-loaded with the action and resource, and every word contributes meaningful information. No unnecessary filler or repetition.

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

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

Given the tool's simplicity (no parameters, no output schema), the description adequately covers the core purpose and the data fields returned. It does not detail the exact output format (e.g., array vs object) or mention sorting/ordering, but for a basic listing tool this is a minor gap. The description is complete enough for an agent to understand what the tool does 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?

This tool has zero parameters, so the baseline score is 4. The description correctly provides no parameter information since there are none, aligning with the input schema. It cannot add further semantic value beyond the baseline.

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

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

The description clearly states the tool's function: listing all known devices from a specific source (DeviceList.json) with the included fields (SN, CRURL, last connection time). The verb '列出' (list) is specific, and the resource 'devices' is unambiguous, distinguishing it from siblings like acs_find_device which targets specific devices.

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

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

The description provides clear context for when to use the tool: when you need all known devices. It does not explicitly mention alternatives or exclusions, but the scope ('all known devices') implicitly defines usage. A score above 3 is warranted as the context is immediately understandable without searching for alternatives.

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

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

No annotations are provided, so the description carries the full burden. It adds minimal transparency by specifying 'all available', but it does not disclose the return format, potential side effects (though listing implies read-only), or any operational prerequisites like an active ACS connection.

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

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

The description is a single, front-loaded sentence that conveys the essential operation without unnecessary words. Every word contributes to understanding the tool's purpose.

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

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

Given the tool's low complexity (no parameters, no output schema), the description is minimal but functional. However, it lacks detail on what the returned data looks like (e.g., array of script names or IDs) and any limitations (e.g., only lists scripts on the current device). It is adequate for a simple list tool but not fully complete.

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

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

The tool has zero parameters, so the baseline is 4. The description does not need to add parameter-level detail, and the schema (empty) is fully documented as having no 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 'list all available TR-069 scripts' using a specific verb ('list') and a specific resource ('TR-069 scripts'). This distinguishes it from sibling tools that operate on individual scripts, such as get_script, create_script, delete_script, and run_script.

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 you need to enumerate available scripts) but provides no explicit guidance on when to use this tool versus alternatives like acs_get_script or acs_find_device. No when-not scenarios or alternative tool mentions are included.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'push config' but does not reveal side effects, reversibility, or whether it restarts devices or applies changes. For a mutating operation, this is a significant transparency gap.

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

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

The description is a single, front-loaded sentence conveying the essential action and mechanism. Every word earns its place, with no fluff or redundancy.

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

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

For a parameterless action, the description is adequate but minimal. It tells what the tool does but lacks context on when to invoke it (e.g., after config changes), what happens after pushing, or how it relates to other sibling tools. With no annotations or output schema, this is a clear gap in 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 zero parameters, so the description need not explain parameter meanings. The baseline for 0 parameters is 4, and the description adds no conflicting or missing information.

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 pushes configuration immediately, with the parenthetical 'execute push script' clarifying the mechanism. This distinguishes it from sibling tools like upload_config or deploy_config by specifying the push action.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, scenarios, or whether other tools should be used first. Only the action is stated, leaving the agent without context for decision-making.

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 disclosing behavioral traits. It simply says 'reboot device' without mentioning potential side effects such as device downtime, required permissions, or irreversibility. This is a significant gap for a mutating operation.

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

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

The description is extremely concise, containing just the essential verb and object with no unnecessary words. It is front-loaded and efficient, though it might be too minimal for a tool with potential side effects. Still, from a conciseness standpoint, it earns a high score.

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 reboot operation, the description is incomplete. It does not explain the impact on the device (e.g., temporary unavailability), any required authentication, or the expected outcome. Given there is no output schema, the description should provide more context to help the agent understand the tool's full behavior.

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

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

The input schema already provides complete description for the only parameter 'sn' (设备序列号), and the description does not add any additional semantics. Since schema coverage is 100%, the baseline of 3 is appropriate; the description adds no extra value but also does not create confusion.

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

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

The description '重启设备' clearly states the action (reboot) and resource (device), making the purpose immediately understandable. However, it does not differentiate from the sibling tool 'acs_restart', which might also involve restarting something, so it falls short of a 5.

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

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

The description offers no guidance on when to use this tool versus alternatives like 'acs_restart'. There is no mention of prerequisite conditions, exclusions, or typical scenarios. This leaves the agent uncertain about selecting the correct tool.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It merely states 'restart' without explaining potential downtime, impact on ongoing operations, whether it is equivalent to stop+start, or what the result/response looks like. This is a significant gap for a server-restart 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, clear sentence with no wasted words. It is very concise, though somewhat under-specified for a tool with parameters. It avoids tautology but lacks additional context that would make it more helpful.

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 restart tool with no annotations and no output schema, the description is too sparse. It doesn't explain the operational effects (e.g., server downtime), return behavior, or any necessary context about how it differs from start/stop. The presence of optional parameters also suggests more guidance 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?

The input schema provides 100% description coverage for all three parameters (mass, port, silent). The description adds no additional parameter information beyond what the schema already contains, so the baseline of 3 is appropriate.

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

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

The description clearly states the verb '重启' (restart) and the resource 'miniACS 服务器' (miniACS server), specifying exactly what the tool does. It is unambiguous and distinguishes itself from siblings like acs_start and acs_stop by indicating a restart operation.

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

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

The description provides no guidance on when to use this tool versus alternatives like acs_start or acs_stop. While restart could be implied as 'stop then start', there is no explicit context for when it should be preferred, nor any exclusions or prerequisites.

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

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

With no annotations, the description carries the full burden for behavioral disclosure, but it merely states the action without revealing any side effects, required permissions, or execution details. Running a script likely has consequences, but the description gives no hint of them.

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

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

The description is a single short sentence with no filler. It is front-loaded with the key action and resource, making it easy to scan. It could include more useful details, but on pure conciseness it scores well.

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 is a mutation action with no output schema and no annotations, the description is incomplete. It does not explain what happens when the script runs, whether it is destructive, or what the expected result is. This leaves significant gaps for an agent deciding to invoke it.

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

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

The single parameter 'name' is fully described in the schema (100% coverage) as '脚本文件名' (script file name). The description adds no additional meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb ('运行' = run) and resource ('TR-069 脚本' = TR-069 script), clearly indicating the tool's function. It distinguishes from sibling tools like acs_list_scripts or acs_get_script, which only list or retrieve scripts, not execute them.

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

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

No guidance is provided on when to use this tool versus alternatives such as acs_exec_raw or acs_set_sequence. There is no context about prerequisites, typical use cases, or situations where another tool would be appropriate.

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 for behavioral disclosure. It reveals the temporary-script mechanism, but does not state whether changes are persistent, what permissions are needed, or what side effects occur from creating/executing a temporary script.

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

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

The description is a single, front-loaded sentence that conveys the action, target, and method without any filler. It is concise and to the point.

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 and schema together cover the core action and parameters, making it minimally viable. However, with no output schema and no annotations, it lacks information about return values, failure modes, or operational prerequisites, so it is not fully complete.

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

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

The schema already fully documents both parameters (sn and params) with descriptions and an example, so baseline is 3. The description adds no extra semantic detail beyond the mechanism, but that is not required given 100% 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 sets device parameter values (设置设备参数值) and specifies the mechanism via SetParameterValues. This distinguishes it from sibling tools like acs_get_parameters, making the purpose unambiguous.

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

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

No usage guidance is provided. There is no mention of when to use this tool versus alternatives such as acs_get_parameters, acs_exec_raw, or acs_run_script, nor any prerequisites like device connectivity or authentication.

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 the key consequence (automatic config delivery on next connection) but omits details like persistence, reversibility, or whether it overrides existing flags. While the main behavior is clear, deeper side effects are not addressed.

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, compact sentence that states the action first and the consequence second, with no redundant information.

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

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

For a simple flag-setting operation with one optional parameter and no output schema, the description covers the essential purpose. However, it lacks context about workflow placement relative to sibling tools (e.g., whether this flag is consumed by acs_push_config) and does not explain what happens if the device is offline or the flag is set repeatedly.

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 single parameter 'sn' is fully documented in the schema (device serial number, default ARC2025001). The description adds no additional parameter information, so the schema suffices; a 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 tool's function: setting the Push flag to trigger automatic configuration delivery on the device's next connection. The verb '设置' (set) and resource 'Push 标志' (Push flag) are specific, and the deferred-trigger behavior ('下次连接时') distinguishes it from immediate push tools like acs_push_config.

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 used to schedule configuration deployment via a flag, but it does not explicitly state when to prefer this over alternatives such as acs_push_config or acs_deploy_config. No exclusions or alternative tools are mentioned.

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

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

With no annotations, the description carries full responsibility for disclosing behavioral traits. It merely restates the tool name ('set script execution sequence') without mentioning whether the new sequence overwrites an existing one, whether it takes effect immediately, or any side effects. This is effectively a tautology.

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

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

The description is a single short sentence that directly conveys the core purpose without any filler or redundancy. It is well-structured and front-loaded, earning a high score for 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?

Although the tool has only one parameter and no output schema, the description fails to provide necessary context such as whether the sequence replaces existing scripts, whether order matters (already implied but not explicitly stated), or what happens after setting. Given the lack of annotations, this is incomplete for a mutation tool.

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

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

The schema already provides 100% coverage for the sole 'scripts' parameter, including a concrete example (e.g., ["GetParameterValue.txt", "Reboot.lua"]). The description adds no extra parameter meaning, so the baseline score of 3 is appropriate.

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

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

The description '设置脚本执行序列' (set script execution sequence) identifies a specific verb ('set') and resource ('script execution sequence'), clearly distinguishing it from sibling tools like acs_run_script or acs_get_sequence. However, it does not explicitly explain what 'sequence' entails (e.g., ordered execution), 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. It does not mention that acs_run_script executes a single script, acs_get_sequence retrieves the current sequence, or whether this tool should be used before starting a session. Usage context is entirely absent.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It fails to mention what 'starting' entails: whether it is blocking, whether it fails if port is in use, whether it spawns a background process, or what output is returned. The phrase merely restates the tool's function without adding any behavioral depth.

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

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

The description is a single, front-loaded sentence with no wasted words. It is efficiently concise, though it lacks any explanatory substance that would make it more valuable; still, for the simplicity of the tool, it is an appropriate size.

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 having a well-documented parameter schema, the description is incomplete for a tool with no annotations and no output schema. It does not state return values, failure modes, or how to verify the server started. Sibling tools like acs_status imply the need for such context, which is missing here.

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

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

Input schema coverage is 100%, so the baseline is 3. The description adds no extra parameter context beyond what the schema already provides (mass, port, silent, logFile), and does not clarify relationships between parameters or defaults 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 '启动 miniACS 服务器' (Start miniACS server) states a clear, specific action with a distinct resource. It directly differentiates from sibling tools like acs_stop and acs_restart by naming 'start' as the operation.

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

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

The description provides no guidance on when to use this tool versus alternatives such as acs_restart or acs_status. There is no mention of prerequisites (e.g., server not already running) or exclusions, so an agent gets no context beyond the obvious action.

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

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

No annotations are provided, so the description carries the burden. The verb '获取' implies a read-only operation with no side effects, and the listed output fields (running, PID, port) clarify what the tool returns. However, it does not mention permission requirements, rate limits, or error behavior, leaving some transparency gaps.

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

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

The description is a single, concise sentence that packs in the key information: what the tool does and what it returns. There is no redundant text, and it is immediately understandable.

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 adequately covers the return values (running state, PID, port) despite lacking an output schema. It is complete enough for a simple status-check tool, though it does not detail data types or error handling, which are not critical for such a tool.

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

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

The tool has zero parameters, and the input schema is empty. Per the rubric, a baseline of 4 is appropriate since there is no need to describe parameter semantics beyond what already exists.

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

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

The description clearly states the tool retrieves the miniACS server running status, listing specific attributes (running state, PID, port). The verb '获取' (get) and resource are specific, distinguishing it from sibling tools like acs_start, acs_stop, etc.

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 implied usage is to check server status, which is evident from the tool name and description. However, it does not explicitly mention when to use it versus alternative tools, nor does it provide guidance on prerequisites or exclusions. The context is clear but not elaborated.

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

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

With no annotations, the description carries full burden for behavioral disclosure. It only states the action 'stop' without explaining effects such as whether the shutdown is graceful, whether it is reversible, or what state the server will be left in.

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, clear sentence with no wasted words. It fully conveys the purpose in minimal 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?

Given the tool's simplicity (no parameters, no output schema, and minimal annotations), the description is adequate for a basic stop command. However, it lacks any context about what happens after stopping, which might be helpful for the agent to verify the outcome.

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

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

The tool has zero parameters, and the schema itself shows an empty properties object. The description does not need to add parameter details, so the baseline score of 4 applies.

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

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

The description '停止 miniACS 服务器' uses a specific verb (stop) and resource (miniACS server), clearly distinguishing it from sibling tools like acs_start and acs_restart.

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 used to stop the server, but it provides no explicit guidance on when to use it instead of acs_restart or acs_status. It does not mention exclusions or alternative 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, the description carries the full burden. It discloses auto-reconnect after parameter changes, which is important. However, it omits other behavioral aspects such as whether existing connections are dropped, whether changes are reversible, or what the response/status output looks like. The core 'no restart + auto reconnect' is useful 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 only two short sentences, front-loaded with the core purpose and then the key behavior. Every word earns its place; no redundant information.

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

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

Given the tool's simplicity (no output schema, no nested objects, all parameters optional), the description covers the main operational context: dynamic modification without restart, auto reconnect. It lacks explicit return-value information but the core use case is well expressed. Slightly more detail on side effects would push it to 5.

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

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

The input schema already covers all five parameters with clear descriptions (host, port, password, username, acsBasePath). The description adds no extra parameter-level semantics beyond saying 'connection parameters', so the baseline of 3 applies due to full 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 function: dynamically modify ACS server connection configuration without restarting the MCP server. This distinguishes it from sibling tools like acs_get_config or acs_upload_config, which deal with device configuration, not server connection 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 when to use it: when you need to change connection parameters, and highlights the benefit of no restart and automatic reconnection. It does not explicitly list exclusions or alternatives, but the context of siblings and the 'no restart' point effectively steer the agent toward this tool for live config updates.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not mention side effects, permissions required, reversibility, or the RPC nature (beyond the label). For an upload operation that likely modifies server state, this lacks critical 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, front-loading the core action. The parenthetical 'Upload RPC' adds a small amount of extra context without waste. It is efficient, though slightly terse.

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 params, 2 required), lack of annotations, and no output schema, the description is insufficient. It provides no context about upload workflow, possible failures, or how it differs from related config tools. The agent has to infer most operational details.

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

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

Schema coverage is 100%, so the baseline is 3. The description does not add any parameter semantics beyond the schema. It does not explain the relationship between params (e.g., username/password for uploadUrl) or any special behavior, but the schema already covers the parameter names.

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

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

The description clearly states the action ('upload config file') and source ('from device'), and the parenthetical 'Upload RPC' reinforces the mechanism. It distinguishes from sibling tools like acs_download_config (download) and acs_push_config (push), making the purpose unambiguous.

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

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

No guidance is given on when to use this tool versus alternatives. There is no explicit context, prerequisites, or exclusions. The description merely states what it does, leaving the agent to infer usage from the tool name and sibling context.

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